{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load \"~/sympy_work_code/environment.py\"\n",
    "from sympy import *\n",
    "from sympy.abc import x,y,z,t,k,l,n,m,p,q\n",
    "from sympy.calculus.util import *\n",
    "from sympy.stats import *\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from sys import path\n",
    "path.append(\"/home/huang/Documents/packaging_tutorial/src\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "%load_ext autoreload \n",
    "%autoreload 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "%aimport basic_package.utils\n",
    "%aimport function_calculator_package.extreme_points\n",
    "%aimport quadratic_function.utils\n",
    "%aimport quadratic_function.hyperbola\n",
    "%aimport quadratic_function.utils\n",
    "\n",
    "from basic_package.utils import *\n",
    "from function_calculator_package.extreme_points import *\n",
    "from quadratic_function.quadraticfunction import QuadraticFunction\n",
    "from quadratic_function.hyperbola import Hyperbola\n",
    "from quadratic_function.utils import line_and_quadratic\n",
    "\n",
    "%aimport solver.utils\n",
    "from solver.utils import solve_univariate_inequalities\n",
    "\n",
    "%aimport function_calculator_package.utils \n",
    "from function_calculator_package.utils import function_is_odd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.frustum\n",
    "%aimport geometry3D.prism\n",
    "%aimport geometry3D.pyramid\n",
    "from geometry3D.frustum import Frustum\n",
    "from geometry3D.prism import Prism,Cube\n",
    "from geometry3D.pyramid import Pyramid,Cone,Tetrahedron\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.frustum\n",
    "from geometry3D.frustum import Frustum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqe=RegularPolygon(Point(0,0),2*sqrt(2),4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Point2D(2*sqrt(2), 0),\n",
       " Point2D(0, 2*sqrt(2)),\n",
       " Point2D(-2*sqrt(2), 0),\n",
       " Point2D(0, -2*sqrt(2))]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqe.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqe1=RegularPolygon(Point(0,0),sqrt(2),4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Point2D(sqrt(2), 0),\n",
       " Point2D(0, sqrt(2)),\n",
       " Point2D(-sqrt(2), 0),\n",
       " Point2D(0, -sqrt(2))]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqe1.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "frum=Frustum(sqe1,sqe,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(\\sqrt{2}, 0, 0\\right), \\  \\operatorname{Point3D}\\left(0, \\sqrt{2}, 0\\right), \\  \\operatorname{Point3D}\\left(- \\sqrt{2}, 0, 0\\right), \\  \\operatorname{Point3D}\\left(0, - \\sqrt{2}, 0\\right), \\  \\operatorname{Point3D}\\left(2 \\sqrt{2}, 0, 0\\right), \\  \\operatorname{Point3D}\\left(0, 2 \\sqrt{2}, 0\\right), \\  \\operatorname{Point3D}\\left(- 2 \\sqrt{2}, 0, 0\\right), \\  \\operatorname{Point3D}\\left(0, - 2 \\sqrt{2}, 0\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(sqrt(2), 0, 0), Point3D(0, sqrt(2), 0), Point3D(-sqrt(2), 0, 0), Point3D(0, -sqrt(2), 0), Point3D(2*sqrt(2), 0, 0), Point3D(0, 2*sqrt(2), 0), Point3D(-2*sqrt(2), 0, 0), Point3D(0, -2*sqrt(2), 0))"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frum.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Point2D(sqrt(2), 0), Point2D(0, sqrt(2)), Point2D(-sqrt(2), 0)]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[*frum.bottoms[0].vertices[0:3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 z$"
      ],
      "text/plain": [
       "4*z"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frum.bottom_planes[0].equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.prism\n",
    "from geometry3D.prism import Prism"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "prism=Prism(Polygon((0,0),(2,0),(2,2),(0,2)),4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "C,D,A,B,C1,D1,A1,B1=prism.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 0, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 0, 0)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 2, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 2, 0)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 0, 4\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 0, 4)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "D2=Point(0,0,2)+D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(2, 0, 2\\right)$"
      ],
      "text/plain": [
       "Point3D(2, 0, 2)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "A2=Point(0,0,1)+A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(2, 2, 1\\right)$"
      ],
      "text/plain": [
       "Point3D(2, 2, 1)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "B2=Point(0,0,2)+B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 2, 2\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 2, 2)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "C2=Point(0,0,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, -2, 1\\right)$"
      ],
      "text/plain": [
       "Point3D(0, -2, 1)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C2-B2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, -2, 1\\right)$"
      ],
      "text/plain": [
       "Point3D(0, -2, 1)"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D2-A2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(-2, -2, 2\\right)$"
      ],
      "text/plain": [
       "Point3D(-2, -2, 2)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C2-A2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=t*B1+(1-t)*B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 2, 4 t\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 2, 4*t)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, -2, 3 - 4 t\\right)$"
      ],
      "text/plain": [
       "Point3D(0, -2, 3 - 4*t)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C2-P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(-2, 0, 1\\right)$"
      ],
      "text/plain": [
       "Point3D(-2, 0, 1)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C2-D2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 2 - 8 t, \\  8 t - 6, \\  -4\\right)$"
      ],
      "text/plain": [
       "(2 - 8*t, 8*t - 6, -4)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,A2,C2).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 2, \\  2, \\  4\\right)$"
      ],
      "text/plain": [
       "(2, 2, 4)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(D2,A2,C2).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 2 - 8 t, \\  8 t - 6, \\  -4\\right)$"
      ],
      "text/plain": [
       "(2 - 8*t, 8*t - 6, -4)"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,A2,C2).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.pyramid\n",
    "from geometry3D.pyramid import Pyramid,Tetrahedron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "cone=Pyramid(3,Circle((1,2),1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\cos{\\left(t \\right)} + 1, \\sin{\\left(t \\right)} + 2\\right)$"
      ],
      "text/plain": [
       "Point2D(cos(t) + 1, sin(t) + 2)"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone.bottom.arbitrary_point()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(1, 2, 3\\right)$"
      ],
      "text/plain": [
       "Point3D(1, 2, 3)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone.vertice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\pi$"
      ],
      "text/plain": [
       "pi"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone.volume"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Line3D}\\left(\\operatorname{Point3D}\\left(0, 0, 0\\right), \\operatorname{Point3D}\\left(0, 0, 2\\right)\\right)$"
      ],
      "text/plain": [
       "Line3D(Point3D(0, 0, 0), Point3D(0, 0, 2))"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line(Point(0,0,0),Point(*cone.bottom_plane.normal_vector))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "m=Line((0,0,0),(0,0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.is_parallel(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{10} \\pi}{5}$"
      ],
      "text/plain": [
       "sqrt(10)*pi/5"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone.sector_angle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "cone=Pyramid(1,Circle((0,0),1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Cone}\\left(\\operatorname{Point3D}\\left(0, 0, 1\\right), \\operatorname{Circle}\\left(\\operatorname{Point2D}\\left(0, 0\\right), 1\\right)\\right)$"
      ],
      "text/plain": [
       "Cone(Point3D(0, 0, 1), Circle(Point2D(0, 0), 1))"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{2} \\pi$"
      ],
      "text/plain": [
       "sqrt(2)*pi"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone.sector_angle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyd=Pyramid(sqrt(3),RegularPolygon((0,0),1,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(0, 0, \\sqrt{3}\\right), \\  \\operatorname{Point3D}\\left(1, 0, 0\\right), \\  \\operatorname{Point3D}\\left(- \\frac{1}{2}, \\frac{\\sqrt{3}}{2}, 0\\right), \\  \\operatorname{Point3D}\\left(- \\frac{1}{2}, - \\frac{\\sqrt{3}}{2}, 0\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(0, 0, sqrt(3)), Point3D(1, 0, 0), Point3D(-1/2, sqrt(3)/2, 0), Point3D(-1/2, -sqrt(3)/2, 0))"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pyd.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "O=Point(0,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "D,A,B,C=pyd.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=t*D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 0, \\sqrt{3} t\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 0, sqrt(3)*t)"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, -sqrt(3)*t]"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line(P,A).direction_ratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( - 3 t, \\  0, \\  \\frac{\\sqrt{3}}{2}\\right)$"
      ],
      "text/plain": [
       "(-3*t, 0, sqrt(3)/2)"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,B,C).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function plot in module sympy.plotting.plot:\n",
      "\n",
      "plot(*args, show=True, **kwargs)\n",
      "    Plots a function of a single variable as a curve.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    args :\n",
      "        The first argument is the expression representing the function\n",
      "        of single variable to be plotted.\n",
      "    \n",
      "        The last argument is a 3-tuple denoting the range of the free\n",
      "        variable. e.g. ``(x, 0, 5)``\n",
      "    \n",
      "        Typical usage examples are in the followings:\n",
      "    \n",
      "        - Plotting a single expression with a single range.\n",
      "            ``plot(expr, range, **kwargs)``\n",
      "        - Plotting a single expression with the default range (-10, 10).\n",
      "            ``plot(expr, **kwargs)``\n",
      "        - Plotting multiple expressions with a single range.\n",
      "            ``plot(expr1, expr2, ..., range, **kwargs)``\n",
      "        - Plotting multiple expressions with multiple ranges.\n",
      "            ``plot((expr1, range1), (expr2, range2), ..., **kwargs)``\n",
      "    \n",
      "        It is best practice to specify range explicitly because default\n",
      "        range may change in the future if a more advanced default range\n",
      "        detection algorithm is implemented.\n",
      "    \n",
      "    show : bool, optional\n",
      "        The default value is set to ``True``. Set show to ``False`` and\n",
      "        the function will not display the plot. The returned instance of\n",
      "        the ``Plot`` class can then be used to save or display the plot\n",
      "        by calling the ``save()`` and ``show()`` methods respectively.\n",
      "    \n",
      "    line_color : string, or float, or function, optional\n",
      "        Specifies the color for the plot.\n",
      "        See ``Plot`` to see how to set color for the plots.\n",
      "        Note that by setting ``line_color``, it would be applied simultaneously\n",
      "        to all the series.\n",
      "    \n",
      "    title : str, optional\n",
      "        Title of the plot. It is set to the latex representation of\n",
      "        the expression, if the plot has only one expression.\n",
      "    \n",
      "    label : str, optional\n",
      "        The label of the expression in the plot. It will be used when\n",
      "        called with ``legend``. Default is the name of the expression.\n",
      "        e.g. ``sin(x)``\n",
      "    \n",
      "    xlabel : str or expression, optional\n",
      "        Label for the x-axis.\n",
      "    \n",
      "    ylabel : str or expression, optional\n",
      "        Label for the y-axis.\n",
      "    \n",
      "    xscale : 'linear' or 'log', optional\n",
      "        Sets the scaling of the x-axis.\n",
      "    \n",
      "    yscale : 'linear' or 'log', optional\n",
      "        Sets the scaling of the y-axis.\n",
      "    \n",
      "    axis_center : (float, float), optional\n",
      "        Tuple of two floats denoting the coordinates of the center or\n",
      "        {'center', 'auto'}\n",
      "    \n",
      "    xlim : (float, float), optional\n",
      "        Denotes the x-axis limits, ``(min, max)```.\n",
      "    \n",
      "    ylim : (float, float), optional\n",
      "        Denotes the y-axis limits, ``(min, max)```.\n",
      "    \n",
      "    annotations : list, optional\n",
      "        A list of dictionaries specifying the type of annotation\n",
      "        required. The keys in the dictionary should be equivalent\n",
      "        to the arguments of the :external:mod:`matplotlib`'s\n",
      "        :external:meth:`~matplotlib.axes.Axes.annotate` method.\n",
      "    \n",
      "    markers : list, optional\n",
      "        A list of dictionaries specifying the type the markers required.\n",
      "        The keys in the dictionary should be equivalent to the arguments\n",
      "        of the :external:mod:`matplotlib`'s :external:func:`~matplotlib.pyplot.plot()` function\n",
      "        along with the marker related keyworded arguments.\n",
      "    \n",
      "    rectangles : list, optional\n",
      "        A list of dictionaries specifying the dimensions of the\n",
      "        rectangles to be plotted. The keys in the dictionary should be\n",
      "        equivalent to the arguments of the :external:mod:`matplotlib`'s\n",
      "        :external:class:`~matplotlib.patches.Rectangle` class.\n",
      "    \n",
      "    fill : dict, optional\n",
      "        A dictionary specifying the type of color filling required in\n",
      "        the plot. The keys in the dictionary should be equivalent to the\n",
      "        arguments of the :external:mod:`matplotlib`'s\n",
      "        :external:meth:`~matplotlib.axes.Axes.fill_between` method.\n",
      "    \n",
      "    adaptive : bool, optional\n",
      "        The default value is set to ``True``. Set adaptive to ``False``\n",
      "        and specify ``nb_of_points`` if uniform sampling is required.\n",
      "    \n",
      "        The plotting uses an adaptive algorithm which samples\n",
      "        recursively to accurately plot. The adaptive algorithm uses a\n",
      "        random point near the midpoint of two points that has to be\n",
      "        further sampled. Hence the same plots can appear slightly\n",
      "        different.\n",
      "    \n",
      "    depth : int, optional\n",
      "        Recursion depth of the adaptive algorithm. A depth of value\n",
      "        `n` samples a maximum of `2^{n}` points.\n",
      "    \n",
      "        If the ``adaptive`` flag is set to ``False``, this will be\n",
      "        ignored.\n",
      "    \n",
      "    nb_of_points : int, optional\n",
      "        Used when the ``adaptive`` is set to ``False``. The function\n",
      "        is uniformly sampled at ``nb_of_points`` number of points.\n",
      "    \n",
      "        If the ``adaptive`` flag is set to ``True``, this will be\n",
      "        ignored.\n",
      "    \n",
      "    size : (float, float), optional\n",
      "        A tuple in the form (width, height) in inches to specify the size of\n",
      "        the overall figure. The default value is set to ``None``, meaning\n",
      "        the size will be set by the default backend.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    .. plot::\n",
      "       :context: close-figs\n",
      "       :format: doctest\n",
      "       :include-source: True\n",
      "    \n",
      "       >>> from sympy import symbols\n",
      "       >>> from sympy.plotting import plot\n",
      "       >>> x = symbols('x')\n",
      "    \n",
      "    Single Plot\n",
      "    \n",
      "    .. plot::\n",
      "       :context: close-figs\n",
      "       :format: doctest\n",
      "       :include-source: True\n",
      "    \n",
      "       >>> plot(x**2, (x, -5, 5))\n",
      "       Plot object containing:\n",
      "       [0]: cartesian line: x**2 for x over (-5.0, 5.0)\n",
      "    \n",
      "    Multiple plots with single range.\n",
      "    \n",
      "    .. plot::\n",
      "       :context: close-figs\n",
      "       :format: doctest\n",
      "       :include-source: True\n",
      "    \n",
      "       >>> plot(x, x**2, x**3, (x, -5, 5))\n",
      "       Plot object containing:\n",
      "       [0]: cartesian line: x for x over (-5.0, 5.0)\n",
      "       [1]: cartesian line: x**2 for x over (-5.0, 5.0)\n",
      "       [2]: cartesian line: x**3 for x over (-5.0, 5.0)\n",
      "    \n",
      "    Multiple plots with different ranges.\n",
      "    \n",
      "    .. plot::\n",
      "       :context: close-figs\n",
      "       :format: doctest\n",
      "       :include-source: True\n",
      "    \n",
      "       >>> plot((x**2, (x, -6, 6)), (x, (x, -5, 5)))\n",
      "       Plot object containing:\n",
      "       [0]: cartesian line: x**2 for x over (-6.0, 6.0)\n",
      "       [1]: cartesian line: x for x over (-5.0, 5.0)\n",
      "    \n",
      "    No adaptive sampling.\n",
      "    \n",
      "    .. plot::\n",
      "       :context: close-figs\n",
      "       :format: doctest\n",
      "       :include-source: True\n",
      "    \n",
      "       >>> plot(x**2, adaptive=False, nb_of_points=400)\n",
      "       Plot object containing:\n",
      "       [0]: cartesian line: x**2 for x over (-10.0, 10.0)\n",
      "    \n",
      "    See Also\n",
      "    ========\n",
      "    \n",
      "    Plot, LineOver1DRangeSeries\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_set={\"axis_center\":(0,0),\"ylim\":(-5,5),\"size\":(10,10)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7f7b4a148a90>"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(x/(x-1),2**x,log(x,2),(x,-3,6),**plot_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 1, \\  2, \\  3\\right)$"
      ],
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(Tuple(1,2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.prism \n",
    "from geometry3D.prism import Cube"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "cube=Cube(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(0, 0, 0\\right), \\  \\operatorname{Point3D}\\left(2, 0, 0\\right), \\  \\operatorname{Point3D}\\left(2, 2, 0\\right), \\  \\operatorname{Point3D}\\left(0, 2, 0\\right), \\  \\operatorname{Point3D}\\left(0, 0, 2\\right), \\  \\operatorname{Point3D}\\left(2, 0, 2\\right), \\  \\operatorname{Point3D}\\left(2, 2, 2\\right), \\  \\operatorname{Point3D}\\left(0, 2, 2\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(0, 0, 0), Point3D(2, 0, 0), Point3D(2, 2, 0), Point3D(0, 2, 0), Point3D(0, 0, 2), Point3D(2, 0, 2), Point3D(2, 2, 2), Point3D(0, 2, 2))"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cube.vertices\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B,C,D,A1,B1,C1,D1=cube.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "N=(C+D+C1+D1)/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(1, 2, 1\\right)$"
      ],
      "text/plain": [
       "Point3D(1, 2, 1)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.polygon3D\n",
    "from geometry3D.polygon3D import Polygon3D,Triangle3D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "ted=Pyramid(N,Polygon3D(C,B1,C1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(1, 2, 1\\right), \\  \\operatorname{Point3D}\\left(2, 2, 0\\right), \\  \\operatorname{Point3D}\\left(2, 0, 2\\right), \\  \\operatorname{Point3D}\\left(2, 2, 2\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(1, 2, 1), Point3D(2, 2, 0), Point3D(2, 0, 2), Point3D(2, 2, 2))"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ted.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Sphere}\\left(\\operatorname{Point3D}\\left(2, 1, 1\\right), \\sqrt{2}\\right)$"
      ],
      "text/plain": [
       "Sphere(Point3D(2, 1, 1), sqrt(2))"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ted.circumsphere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.sphere\n",
    "from geometry3D.sphere import Sphere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b=symbols(\"a,b\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "cone=Pyramid(a,Circle((0,0),b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Cone}\\left(\\operatorname{Point3D}\\left(0, 0, a\\right), \\operatorname{Circle}\\left(\\operatorname{Point2D}\\left(0, 0\\right), b\\right)\\right)$"
      ],
      "text/plain": [
       "Cone(Point3D(0, 0, a), Circle(Point2D(0, 0), b))"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\pi b^{2}$"
      ],
      "text/plain": [
       "pi*b**2"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone.bottom.area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\pi b}{\\sqrt{a^{2} + b^{2}}}$"
      ],
      "text/plain": [
       "2*pi*b/sqrt(a**2 + b**2)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone.sector_angle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\pi b \\sqrt{a^{2} + b^{2}}$"
      ],
      "text/plain": [
       "pi*b*sqrt(a**2 + b**2)"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone.generatrix**2*cone.sector_angle/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "cone=Pyramid(3,Circle((0,0),sqrt(3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 6 \\pi$"
      ],
      "text/plain": [
       "6*pi"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone.side_area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Abs in module sympy.functions.elementary.complexes:\n",
      "\n",
      "class Abs(sympy.core.function.Function)\n",
      " |  Abs(arg)\n",
      " |  \n",
      " |  Return the absolute value of the argument.\n",
      " |  \n",
      " |  Explanation\n",
      " |  ===========\n",
      " |  \n",
      " |  This is an extension of the built-in function ``abs()`` to accept symbolic\n",
      " |  values.  If you pass a SymPy expression to the built-in ``abs()``, it will\n",
      " |  pass it automatically to ``Abs()``.\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Abs, Symbol, S, I\n",
      " |  >>> Abs(-1)\n",
      " |  1\n",
      " |  >>> x = Symbol('x', real=True)\n",
      " |  >>> Abs(-x)\n",
      " |  Abs(x)\n",
      " |  >>> Abs(x**2)\n",
      " |  x**2\n",
      " |  >>> abs(-x) # The Python built-in\n",
      " |  Abs(x)\n",
      " |  >>> Abs(3*x + 2*I)\n",
      " |  sqrt(9*x**2 + 4)\n",
      " |  >>> Abs(8*I)\n",
      " |  8\n",
      " |  \n",
      " |  Note that the Python built-in will return either an Expr or int depending on\n",
      " |  the argument::\n",
      " |  \n",
      " |      >>> type(abs(-1))\n",
      " |      <... 'int'>\n",
      " |      >>> type(abs(S.NegativeOne))\n",
      " |      <class 'sympy.core.numbers.One'>\n",
      " |  \n",
      " |  Abs will always return a SymPy object.\n",
      " |  \n",
      " |  Parameters\n",
      " |  ==========\n",
      " |  \n",
      " |  arg : Expr\n",
      " |      Real or complex expression.\n",
      " |  \n",
      " |  Returns\n",
      " |  =======\n",
      " |  \n",
      " |  expr : Expr\n",
      " |      Absolute value returned can be an expression or integer depending on\n",
      " |      input arg.\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  \n",
      " |  sign, conjugate\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Abs\n",
      " |      sympy.core.function.Function\n",
      " |      sympy.core.function.Application\n",
      " |      sympy.core.expr.Expr\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  fdiff(self, argindex=1)\n",
      " |      Get the first derivative of the argument to Abs().\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  eval(arg) from sympy.core.function.FunctionClass\n",
      " |      Returns a canonical form of cls applied to arguments args.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The eval() method is called when the class cls is about to be\n",
      " |      instantiated and it should return either some simplified instance\n",
      " |      (possible of some other class), or if the class cls should be\n",
      " |      unmodified, return None.\n",
      " |      \n",
      " |      Examples of eval() for the function \"sign\"\n",
      " |      ---------------------------------------------\n",
      " |      \n",
      " |      .. code-block:: python\n",
      " |      \n",
      " |          @classmethod\n",
      " |          def eval(cls, arg):\n",
      " |              if arg is S.NaN:\n",
      " |                  return S.NaN\n",
      " |              if arg.is_zero: return S.Zero\n",
      " |              if arg.is_positive: return S.One\n",
      " |              if arg.is_negative: return S.NegativeOne\n",
      " |              if isinstance(arg, Mul):\n",
      " |                  coeff, terms = arg.as_coeff_Mul(rational=True)\n",
      " |                  if coeff is not S.One:\n",
      " |                      return cls(coeff) * cls(terms)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __annotations__ = {'args': typing.Tuple[sympy.core.expr.Expr]}\n",
      " |  \n",
      " |  default_assumptions = {'extended_real': True, 'imaginary': False, 'com...\n",
      " |  \n",
      " |  is_commutative = True\n",
      " |  \n",
      " |  is_extended_negative = False\n",
      " |  \n",
      " |  is_extended_nonnegative = True\n",
      " |  \n",
      " |  is_extended_real = True\n",
      " |  \n",
      " |  is_imaginary = False\n",
      " |  \n",
      " |  is_negative = False\n",
      " |  \n",
      " |  unbranched = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  as_base_exp(self)\n",
      " |      Returns the method as the 2-tuple (base, exponent).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  class_key() from sympy.core.function.FunctionClass\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  is_singular(a) from sympy.core.function.FunctionClass\n",
      " |      Tests whether the argument is an essential singularity\n",
      " |      or a branch point, or the functions is non-holomorphic.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  __new__(cls, *args, **options)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  is_Function = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  __abs__(self) -> 'Expr'\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __complex__(self)\n",
      " |  \n",
      " |  __divmod__(self, other)\n",
      " |  \n",
      " |  __float__(self)\n",
      " |  \n",
      " |  __floordiv__(self, other)\n",
      " |  \n",
      " |  __format__(self, format_spec: 'str')\n",
      " |      Default object formatter.\n",
      " |  \n",
      " |  __ge__(self, other)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __gt__(self, other)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __int__(self)\n",
      " |  \n",
      " |  __le__(self, other)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lt__(self, other)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __neg__(self)\n",
      " |  \n",
      " |  __pos__(self)\n",
      " |  \n",
      " |  __pow__(self, other, mod=None) -> 'Expr'\n",
      " |  \n",
      " |  __radd__(self, other)\n",
      " |  \n",
      " |  __rdivmod__(self, other)\n",
      " |  \n",
      " |  __rfloordiv__(self, other)\n",
      " |  \n",
      " |  __rmod__(self, other)\n",
      " |  \n",
      " |  __rmul__(self, other)\n",
      " |  \n",
      " |  __round__ = round(self, n=None)\n",
      " |  \n",
      " |  __rpow__(self, other)\n",
      " |  \n",
      " |  __rsub__(self, other)\n",
      " |  \n",
      " |  __rtruediv__(self, other)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __truediv__(self, other)\n",
      " |  \n",
      " |  __trunc__(self)\n",
      " |  \n",
      " |  adjoint(self)\n",
      " |  \n",
      " |  apart(self, x=None, **args)\n",
      " |      See the apart function in sympy.polys\n",
      " |  \n",
      " |  args_cnc(self, cset=False, warn=True, split_1=True)\n",
      " |      Return [commutative factors, non-commutative factors] of self.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      self is treated as a Mul and the ordering of the factors is maintained.\n",
      " |      If ``cset`` is True the commutative factors will be returned in a set.\n",
      " |      If there were repeated factors (as may happen with an unevaluated Mul)\n",
      " |      then an error will be raised unless it is explicitly suppressed by\n",
      " |      setting ``warn`` to False.\n",
      " |      \n",
      " |      Note: -1 is always separated from a Number unless split_1 is False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, oo\n",
      " |      >>> A, B = symbols('A B', commutative=0)\n",
      " |      >>> x, y = symbols('x y')\n",
      " |      >>> (-2*x*y).args_cnc()\n",
      " |      [[-1, 2, x, y], []]\n",
      " |      >>> (-2.5*x).args_cnc()\n",
      " |      [[-1, 2.5, x], []]\n",
      " |      >>> (-2*x*A*B*y).args_cnc()\n",
      " |      [[-1, 2, x, y], [A, B]]\n",
      " |      >>> (-2*x*A*B*y).args_cnc(split_1=False)\n",
      " |      [[-2, x, y], [A, B]]\n",
      " |      >>> (-2*x*y).args_cnc(cset=True)\n",
      " |      [{-1, 2, x, y}, []]\n",
      " |      \n",
      " |      The arg is always treated as a Mul:\n",
      " |      \n",
      " |      >>> (-2 + x + A).args_cnc()\n",
      " |      [[], [x - 2 + A]]\n",
      " |      >>> (-oo).args_cnc() # -oo is a singleton\n",
      " |      [[-1, oo], []]\n",
      " |  \n",
      " |  as_coeff_Add(self, rational=False) -> \"tuple['Number', Expr]\"\n",
      " |      Efficiently extract the coefficient of a summation.\n",
      " |  \n",
      " |  as_coeff_Mul(self, rational: 'bool' = False) -> \"tuple['Number', Expr]\"\n",
      " |      Efficiently extract the coefficient of a product.\n",
      " |  \n",
      " |  as_coeff_add(self, *deps) -> 'tuple[Expr, tuple[Expr, ...]]'\n",
      " |      Return the tuple (c, args) where self is written as an Add, ``a``.\n",
      " |      \n",
      " |      c should be a Rational added to any terms of the Add that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other terms of ``a``; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is an Add or not but\n",
      " |      you want to treat self as an Add or if you want to process the\n",
      " |      individual arguments of the tail of self as an Add.\n",
      " |      \n",
      " |      - if you know self is an Add and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail.\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_add()\n",
      " |      (3, ())\n",
      " |      >>> (3 + x).as_coeff_add()\n",
      " |      (3, (x,))\n",
      " |      >>> (3 + x + y).as_coeff_add(x)\n",
      " |      (y + 3, (x,))\n",
      " |      >>> (3 + y).as_coeff_add(x)\n",
      " |      (y + 3, ())\n",
      " |  \n",
      " |  as_coeff_exponent(self, x) -> 'tuple[Expr, Expr]'\n",
      " |      ``c*x**e -> c,e`` where x can be any symbolic expression.\n",
      " |  \n",
      " |  as_coeff_mul(self, *deps, **kwargs) -> 'tuple[Expr, tuple[Expr, ...]]'\n",
      " |      Return the tuple (c, args) where self is written as a Mul, ``m``.\n",
      " |      \n",
      " |      c should be a Rational multiplied by any factors of the Mul that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other factors of m; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is a Mul or not but\n",
      " |      you want to treat self as a Mul or if you want to process the\n",
      " |      individual arguments of the tail of self as a Mul.\n",
      " |      \n",
      " |      - if you know self is a Mul and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail;\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_mul()\n",
      " |      (3, ())\n",
      " |      >>> (3*x*y).as_coeff_mul()\n",
      " |      (3, (x, y))\n",
      " |      >>> (3*x*y).as_coeff_mul(x)\n",
      " |      (3*y, (x,))\n",
      " |      >>> (3*y).as_coeff_mul(x)\n",
      " |      (3*y, ())\n",
      " |  \n",
      " |  as_coefficient(self, expr)\n",
      " |      Extracts symbolic coefficient at the given expression. In\n",
      " |      other words, this functions separates 'self' into the product\n",
      " |      of 'expr' and 'expr'-free coefficient. If such separation\n",
      " |      is not possible it will return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import E, pi, sin, I, Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> E.as_coefficient(E)\n",
      " |      1\n",
      " |      >>> (2*E).as_coefficient(E)\n",
      " |      2\n",
      " |      >>> (2*sin(E)*E).as_coefficient(E)\n",
      " |      \n",
      " |      Two terms have E in them so a sum is returned. (If one were\n",
      " |      desiring the coefficient of the term exactly matching E then\n",
      " |      the constant from the returned expression could be selected.\n",
      " |      Or, for greater precision, a method of Poly can be used to\n",
      " |      indicate the desired term from which the coefficient is\n",
      " |      desired.)\n",
      " |      \n",
      " |      >>> (2*E + x*E).as_coefficient(E)\n",
      " |      x + 2\n",
      " |      >>> _.args[0]  # just want the exact match\n",
      " |      2\n",
      " |      >>> p = Poly(2*E + x*E); p\n",
      " |      Poly(x*E + 2*E, x, E, domain='ZZ')\n",
      " |      >>> p.coeff_monomial(E)\n",
      " |      2\n",
      " |      >>> p.nth(0, 1)\n",
      " |      2\n",
      " |      \n",
      " |      Since the following cannot be written as a product containing\n",
      " |      E as a factor, None is returned. (If the coefficient ``2*x`` is\n",
      " |      desired then the ``coeff`` method should be used.)\n",
      " |      \n",
      " |      >>> (2*E*x + x).as_coefficient(E)\n",
      " |      >>> (2*E*x + x).coeff(E)\n",
      " |      2*x\n",
      " |      \n",
      " |      >>> (E*(x + 1) + x).as_coefficient(E)\n",
      " |      \n",
      " |      >>> (2*pi*I).as_coefficient(pi*I)\n",
      " |      2\n",
      " |      >>> (2*I).as_coefficient(pi*I)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      coeff: return sum of terms have a given factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  as_coefficients_dict(self, *syms)\n",
      " |      Return a dictionary mapping terms to their Rational coefficient.\n",
      " |      Since the dictionary is a defaultdict, inquiries about terms which\n",
      " |      were not present will return a coefficient of 0.\n",
      " |      \n",
      " |      If symbols ``syms`` are provided, any multiplicative terms\n",
      " |      independent of them will be considered a coefficient and a\n",
      " |      regular dictionary of syms-dependent generators as keys and\n",
      " |      their corresponding coefficients as values will be returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import a, x, y\n",
      " |      >>> (3*x + a*x + 4).as_coefficients_dict()\n",
      " |      {1: 4, x: 3, a*x: 1}\n",
      " |      >>> _[a]\n",
      " |      0\n",
      " |      >>> (3*a*x).as_coefficients_dict()\n",
      " |      {a*x: 3}\n",
      " |      >>> (3*a*x).as_coefficients_dict(x)\n",
      " |      {x: 3*a}\n",
      " |      >>> (3*a*x).as_coefficients_dict(y)\n",
      " |      {1: 3*a*x}\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      This method should recursively remove a Rational from all arguments\n",
      " |      and return that (content) and the new self (primitive). The content\n",
      " |      should always be positive and ``Mul(*foo.as_content_primitive()) == foo``.\n",
      " |      The primitive need not be in canonical form and should try to preserve\n",
      " |      the underlying structure if possible (i.e. expand_mul should not be\n",
      " |      applied to self).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> eq = 2 + 2*x + 2*y*(3 + 3*y)\n",
      " |      \n",
      " |      The as_content_primitive function is recursive and retains structure:\n",
      " |      \n",
      " |      >>> eq.as_content_primitive()\n",
      " |      (2, x + 3*y*(y + 1) + 1)\n",
      " |      \n",
      " |      Integer powers will have Rationals extracted from the base:\n",
      " |      \n",
      " |      >>> ((2 + 6*x)**2).as_content_primitive()\n",
      " |      (4, (3*x + 1)**2)\n",
      " |      >>> ((2 + 6*x)**(2*y)).as_content_primitive()\n",
      " |      (1, (2*(3*x + 1))**(2*y))\n",
      " |      \n",
      " |      Terms may end up joining once their as_content_primitives are added:\n",
      " |      \n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (11, x*(y + 1))\n",
      " |      >>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (9, x*(y + 1))\n",
      " |      >>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (1, 6.0*x*(y + 1) + 3*z*(y + 1))\n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (121, x**2*(y + 1)**2)\n",
      " |      >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (1, 4.84*x**2*(y + 1)**2)\n",
      " |      \n",
      " |      Radical content can also be factored out of the primitive:\n",
      " |      \n",
      " |      >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)\n",
      " |      (2, sqrt(2)*(1 + 2*sqrt(5)))\n",
      " |      \n",
      " |      If clear=False (default is True) then content will not be removed\n",
      " |      from an Add if it can be distributed to leave one or more\n",
      " |      terms with integer coefficients.\n",
      " |      \n",
      " |      >>> (x/2 + y).as_content_primitive()\n",
      " |      (1/2, x + 2*y)\n",
      " |      >>> (x/2 + y).as_content_primitive(clear=False)\n",
      " |      (1, x/2 + y)\n",
      " |  \n",
      " |  as_expr(self, *gens)\n",
      " |      Convert a polynomial to a SymPy expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = (x**2 + x*y).as_poly(x, y)\n",
      " |      >>> f.as_expr()\n",
      " |      x**2 + x*y\n",
      " |      \n",
      " |      >>> sin(x).as_expr()\n",
      " |      sin(x)\n",
      " |  \n",
      " |  as_independent(self, *deps, **hint) -> 'tuple[Expr, Expr]'\n",
      " |      A mostly naive separation of a Mul or Add into arguments that are not\n",
      " |      are dependent on deps. To obtain as complete a separation of variables\n",
      " |      as possible, use a separation method first, e.g.:\n",
      " |      \n",
      " |      * separatevars() to change Mul, Add and Pow (including exp) into Mul\n",
      " |      * .expand(mul=True) to change Add or Mul into Add\n",
      " |      * .expand(log=True) to change log expr into an Add\n",
      " |      \n",
      " |      The only non-naive thing that is done here is to respect noncommutative\n",
      " |      ordering of variables and to always return (0, 0) for `self` of zero\n",
      " |      regardless of hints.\n",
      " |      \n",
      " |      For nonzero `self`, the returned tuple (i, d) has the\n",
      " |      following interpretation:\n",
      " |      \n",
      " |      * i will has no variable that appears in deps\n",
      " |      * d will either have terms that contain variables that are in deps, or\n",
      " |        be equal to 0 (when self is an Add) or 1 (when self is a Mul)\n",
      " |      * if self is an Add then self = i + d\n",
      " |      * if self is a Mul then self = i*d\n",
      " |      * otherwise (self, S.One) or (S.One, self) is returned.\n",
      " |      \n",
      " |      To force the expression to be treated as an Add, use the hint as_Add=True\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      -- self is an Add\n",
      " |      \n",
      " |      >>> from sympy import sin, cos, exp\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> (x + x*y).as_independent(x)\n",
      " |      (0, x*y + x)\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x)\n",
      " |      (y + z, 2*x*sin(x) + x)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x, y)\n",
      " |      (z, 2*x*sin(x) + x + y)\n",
      " |      \n",
      " |      -- self is a Mul\n",
      " |      \n",
      " |      >>> (x*sin(x)*cos(y)).as_independent(x)\n",
      " |      (cos(y), x*sin(x))\n",
      " |      \n",
      " |      non-commutative terms cannot always be separated out when self is a Mul\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)\n",
      " |      >>> (n1 + n1*n2).as_independent(n2)\n",
      " |      (n1, n1*n2)\n",
      " |      >>> (n2*n1 + n1*n2).as_independent(n2)\n",
      " |      (0, n1*n2 + n2*n1)\n",
      " |      >>> (n1*n2*n3).as_independent(n1)\n",
      " |      (1, n1*n2*n3)\n",
      " |      >>> (n1*n2*n3).as_independent(n2)\n",
      " |      (n1, n2*n3)\n",
      " |      >>> ((x-n1)*(x-y)).as_independent(x)\n",
      " |      (1, (x - y)*(x - n1))\n",
      " |      \n",
      " |      -- self is anything else:\n",
      " |      \n",
      " |      >>> (sin(x)).as_independent(x)\n",
      " |      (1, sin(x))\n",
      " |      >>> (sin(x)).as_independent(y)\n",
      " |      (sin(x), 1)\n",
      " |      >>> exp(x+y).as_independent(x)\n",
      " |      (1, exp(x + y))\n",
      " |      \n",
      " |      -- force self to be treated as an Add:\n",
      " |      \n",
      " |      >>> (3*x).as_independent(x, as_Add=True)\n",
      " |      (0, 3*x)\n",
      " |      \n",
      " |      -- force self to be treated as a Mul:\n",
      " |      \n",
      " |      >>> (3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x + 3)\n",
      " |      >>> (-3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x - 3)\n",
      " |      \n",
      " |      Note how the below differs from the above in making the\n",
      " |      constant on the dep term positive.\n",
      " |      \n",
      " |      >>> (y*(-3+x)).as_independent(x)\n",
      " |      (y, x - 3)\n",
      " |      \n",
      " |      -- use .as_independent() for true independence testing instead\n",
      " |         of .has(). The former considers only symbols in the free\n",
      " |         symbols while the latter considers all symbols\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> I = Integral(x, (x, 1, 2))\n",
      " |      >>> I.has(x)\n",
      " |      True\n",
      " |      >>> x in I.free_symbols\n",
      " |      False\n",
      " |      >>> I.as_independent(x) == (I, 1)\n",
      " |      True\n",
      " |      >>> (I + x).as_independent(x) == (I, x)\n",
      " |      True\n",
      " |      \n",
      " |      Note: when trying to get independent terms, a separation method\n",
      " |      might need to be used first. In this case, it is important to keep\n",
      " |      track of what you send to this routine so you know how to interpret\n",
      " |      the returned values\n",
      " |      \n",
      " |      >>> from sympy import separatevars, log\n",
      " |      >>> separatevars(exp(x+y)).as_independent(x)\n",
      " |      (exp(y), exp(x))\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> separatevars(x + x*y).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).expand(mul=True).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> a, b=symbols('a b', positive=True)\n",
      " |      >>> (log(a*b).expand(log=True)).as_independent(b)\n",
      " |      (log(a), log(b))\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      .separatevars(), .expand(log=True), sympy.core.add.Add.as_two_terms(),\n",
      " |      sympy.core.mul.Mul.as_two_terms(), .as_coeff_add(), .as_coeff_mul()\n",
      " |  \n",
      " |  as_leading_term(self, *symbols, logx=None, cdir=0)\n",
      " |      Returns the leading (nonzero) term of the series expansion of self.\n",
      " |      \n",
      " |      The _eval_as_leading_term routines are used to do this, and they must\n",
      " |      always return a non-zero value.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + x**2).as_leading_term(x)\n",
      " |      1\n",
      " |      >>> (1/x**2 + x + x**2).as_leading_term(x)\n",
      " |      x**(-2)\n",
      " |  \n",
      " |  as_numer_denom(self)\n",
      " |      expression -> a/b -> a, b\n",
      " |      \n",
      " |      This is just a stub that should be defined by\n",
      " |      an object's class methods to get anything else.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      normal: return ``a/b`` instead of ``(a, b)``\n",
      " |  \n",
      " |  as_ordered_factors(self, order=None)\n",
      " |      Return list of ordered factors (if Mul) else [self].\n",
      " |  \n",
      " |  as_ordered_terms(self, order=None, data=False)\n",
      " |      Transform an expression to an ordered list of terms.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, cos\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()\n",
      " |      [sin(x)**2*cos(x), sin(x)**2, 1]\n",
      " |  \n",
      " |  as_poly(self, *gens, **args)\n",
      " |      Converts ``self`` to a polynomial or returns ``None``.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly())\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly(x, y))\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + sin(y)).as_poly(x, y))\n",
      " |      None\n",
      " |  \n",
      " |  as_powers_dict(self)\n",
      " |      Return self as a dictionary of factors with each factor being\n",
      " |      treated as a power. The keys are the bases of the factors and the\n",
      " |      values, the corresponding exponents. The resulting dictionary should\n",
      " |      be used with caution if the expression is a Mul and contains non-\n",
      " |      commutative factors since the order that they appeared will be lost in\n",
      " |      the dictionary.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      as_ordered_factors: An alternative for noncommutative applications,\n",
      " |                          returning an ordered list of factors.\n",
      " |      args_cnc: Similar to as_ordered_factors, but guarantees separation\n",
      " |                of commutative and noncommutative factors.\n",
      " |  \n",
      " |  as_real_imag(self, deep=True, **hints)\n",
      " |      Performs complex expansion on 'self' and returns a tuple\n",
      " |      containing collected both real and imaginary parts. This\n",
      " |      method cannot be confused with re() and im() functions,\n",
      " |      which does not perform complex expansion at evaluation.\n",
      " |      \n",
      " |      However it is possible to expand both re() and im()\n",
      " |      functions and get exactly the same results as with\n",
      " |      a single call to this function.\n",
      " |      \n",
      " |      >>> from sympy import symbols, I\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> (x + y*I).as_real_imag()\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> from sympy.abc import z, w\n",
      " |      \n",
      " |      >>> (z + w*I).as_real_imag()\n",
      " |      (re(z) - im(w), re(w) + im(z))\n",
      " |  \n",
      " |  as_terms(self)\n",
      " |      Transform an expression to a list of terms.\n",
      " |  \n",
      " |  aseries(self, x=None, n=6, bound=0, hir=False)\n",
      " |      Asymptotic Series expansion of self.\n",
      " |      This is equivalent to ``self.series(x, oo, n)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      self : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |      \n",
      " |      hir : Boolean\n",
      " |            Set this parameter to be True to produce hierarchical series.\n",
      " |            It stops the recursion at an early level and may provide nicer\n",
      " |            and more useful results.\n",
      " |      \n",
      " |      bound : Value, Integer\n",
      " |              Use the ``bound`` parameter to give limit on rewriting\n",
      " |              coefficients in its normalised form.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, exp\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> e = sin(1/x + exp(-x)) - sin(1/x)\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)\n",
      " |      \n",
      " |      >>> e.aseries(x, n=3, hir=True)\n",
      " |      -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))\n",
      " |      \n",
      " |      >>> e = exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x, bound=3) # doctest: +SKIP\n",
      " |      exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))\n",
      " |      \n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).aseries(x, n=8)\n",
      " |      1/x\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr\n",
      " |          Asymptotic series expansion of the expression.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This algorithm is directly induced from the limit computational algorithm provided by Gruntz.\n",
      " |      It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first\n",
      " |      to look for the most rapidly varying subexpression w of a given expression f and then expands f\n",
      " |      in a series in w. Then same thing is recursively done on the leading coefficient\n",
      " |      till we get constant coefficients.\n",
      " |      \n",
      " |      If the most rapidly varying subexpression of a given expression f is f itself,\n",
      " |      the algorithm tries to find a normalised representation of the mrv set and rewrites f\n",
      " |      using this normalised representation.\n",
      " |      \n",
      " |      If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))``\n",
      " |      where ``w`` belongs to the most rapidly varying expression of ``self``.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series.\n",
      " |             In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993.\n",
      " |             pp. 239-244.\n",
      " |      .. [2] Gruntz thesis - p90\n",
      " |      .. [3] http://en.wikipedia.org/wiki/Asymptotic_expansion\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      Expr.aseries: See the docstring of this function for complete details of this wrapper.\n",
      " |  \n",
      " |  cancel(self, *gens, **args)\n",
      " |      See the cancel function in sympy.polys\n",
      " |  \n",
      " |  coeff(self, x, n=1, right=False, _first=True)\n",
      " |      Returns the coefficient from the term(s) containing ``x**n``. If ``n``\n",
      " |      is zero then all terms independent of ``x`` will be returned.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      When ``x`` is noncommutative, the coefficient to the left (default) or\n",
      " |      right of ``x`` can be returned. The keyword 'right' is ignored when\n",
      " |      ``x`` is commutative.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      You can select terms that have an explicit negative in front of them:\n",
      " |      \n",
      " |      >>> (-x + 2*y).coeff(-1)\n",
      " |      x\n",
      " |      >>> (x - 2*y).coeff(-1)\n",
      " |      2*y\n",
      " |      \n",
      " |      You can select terms with no Rational coefficient:\n",
      " |      \n",
      " |      >>> (x + 2*y).coeff(1)\n",
      " |      x\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(1)\n",
      " |      0\n",
      " |      \n",
      " |      You can select terms independent of x by making n=0; in this case\n",
      " |      expr.as_independent(x)[0] is returned (and 0 will be returned instead\n",
      " |      of None):\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x, 0)\n",
      " |      3\n",
      " |      >>> eq = ((x + 1)**3).expand() + 1\n",
      " |      >>> eq\n",
      " |      x**3 + 3*x**2 + 3*x + 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 2]\n",
      " |      >>> eq -= 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 0]\n",
      " |      \n",
      " |      You can select terms that have a numerical term in front of them:\n",
      " |      \n",
      " |      >>> (-x - 2*y).coeff(2)\n",
      " |      -y\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> (x + sqrt(2)*x).coeff(sqrt(2))\n",
      " |      x\n",
      " |      \n",
      " |      The matching is exact:\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x)\n",
      " |      2\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**2)\n",
      " |      4\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**3)\n",
      " |      0\n",
      " |      >>> (z*(x + y)**2).coeff((x + y)**2)\n",
      " |      z\n",
      " |      >>> (z*(x + y)**2).coeff(x + y)\n",
      " |      0\n",
      " |      \n",
      " |      In addition, no factoring is done, so 1 + z*(1 + y) is not obtained\n",
      " |      from the following:\n",
      " |      \n",
      " |      >>> (x + z*(x + x*y)).coeff(x)\n",
      " |      1\n",
      " |      \n",
      " |      If such factoring is desired, factor_terms can be used first:\n",
      " |      \n",
      " |      >>> from sympy import factor_terms\n",
      " |      >>> factor_terms(x + z*(x + x*y)).coeff(x)\n",
      " |      z*(y + 1) + 1\n",
      " |      \n",
      " |      >>> n, m, o = symbols('n m o', commutative=False)\n",
      " |      >>> n.coeff(n)\n",
      " |      1\n",
      " |      >>> (3*n).coeff(n)\n",
      " |      3\n",
      " |      >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m\n",
      " |      1 + m\n",
      " |      >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m\n",
      " |      m\n",
      " |      \n",
      " |      If there is more than one possible coefficient 0 is returned:\n",
      " |      \n",
      " |      >>> (n*m + m*n).coeff(n)\n",
      " |      0\n",
      " |      \n",
      " |      If there is only one possible coefficient, it is returned:\n",
      " |      \n",
      " |      >>> (n*m + x*m*n).coeff(m*n)\n",
      " |      x\n",
      " |      >>> (n*m + x*m*n).coeff(m*n, right=1)\n",
      " |      1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_coefficient: separate the expression into a coefficient and factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True)\n",
      " |      See the collect function in sympy.simplify\n",
      " |  \n",
      " |  combsimp(self)\n",
      " |      See the combsimp function in sympy.simplify\n",
      " |  \n",
      " |  compute_leading_term(self, x, logx=None)\n",
      " |      as_leading_term is only allowed for results of .series()\n",
      " |      This is a wrapper to compute a series first.\n",
      " |  \n",
      " |  conjugate(self)\n",
      " |      Returns the complex conjugate of 'self'.\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |      Return True if self has -1 as a leading factor or has\n",
      " |      more literal negative signs than positive signs in a sum,\n",
      " |      otherwise False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = x - y\n",
      " |      >>> {i.could_extract_minus_sign() for i in (e, -e)}\n",
      " |      {False, True}\n",
      " |      \n",
      " |      Though the ``y - x`` is considered like ``-(x - y)``, since it\n",
      " |      is in a product without a leading factor of -1, the result is\n",
      " |      false below:\n",
      " |      \n",
      " |      >>> (x*(y - x)).could_extract_minus_sign()\n",
      " |      False\n",
      " |      \n",
      " |      To put something in canonical form wrt to sign, use `signsimp`:\n",
      " |      \n",
      " |      >>> from sympy import signsimp\n",
      " |      >>> signsimp(x*(y - x))\n",
      " |      -x*(x - y)\n",
      " |      >>> _.could_extract_minus_sign()\n",
      " |      True\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  diff(self, *symbols, **assumptions)\n",
      " |  \n",
      " |  dir(self, x, cdir)\n",
      " |  \n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if self == other, False if it does not, or None. If\n",
      " |      failing_expression is True then the expression which did not simplify\n",
      " |      to a 0 will be returned instead of None.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If ``self`` is a Number (or complex number) that is not zero, then\n",
      " |      the result is False.\n",
      " |      \n",
      " |      If ``self`` is a number and has not evaluated to zero, evalf will be\n",
      " |      used to test whether the expression evaluates to zero. If it does so\n",
      " |      and the result has significance (i.e. the precision is either -1, for\n",
      " |      a Rational result, or is greater than 1) then the evalf value will be\n",
      " |      used to return True or False.\n",
      " |  \n",
      " |  expand(self, deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)\n",
      " |      Expand an expression using hints.\n",
      " |      \n",
      " |      See the docstring of the expand() function in sympy.core.function for\n",
      " |      more information.\n",
      " |  \n",
      " |  extract_additively(self, c)\n",
      " |      Return self - c if it's possible to subtract c from self and\n",
      " |      make all matching coefficients move towards zero, else return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = 2*x + 3\n",
      " |      >>> e.extract_additively(x + 1)\n",
      " |      x + 2\n",
      " |      >>> e.extract_additively(3*x)\n",
      " |      >>> e.extract_additively(4)\n",
      " |      >>> (y*(x + 1)).extract_additively(x + 1)\n",
      " |      >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)\n",
      " |      (x + 1)*(x + 2*y) + 3\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      extract_multiplicatively\n",
      " |      coeff\n",
      " |      as_coefficient\n",
      " |  \n",
      " |  extract_branch_factor(self, allow_half=False)\n",
      " |      Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way.\n",
      " |      Return (z, n).\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, I, pi\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), 0)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor()\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(-pi*I).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), -1)\n",
      " |      >>> exp_polar(3*pi*I + x).extract_branch_factor()\n",
      " |      (exp_polar(x + I*pi), 1)\n",
      " |      >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()\n",
      " |      (y*exp_polar(2*pi*x), -1)\n",
      " |      >>> exp_polar(-I*pi/2).extract_branch_factor()\n",
      " |      (exp_polar(-I*pi/2), 0)\n",
      " |      \n",
      " |      If allow_half is True, also extract exp_polar(I*pi):\n",
      " |      \n",
      " |      >>> exp_polar(I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1/2)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 3/2)\n",
      " |      >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, -1/2)\n",
      " |  \n",
      " |  extract_multiplicatively(self, c)\n",
      " |      Return None if it's not possible to make self in the form\n",
      " |      c * something in a nice way, i.e. preserving the properties\n",
      " |      of arguments of self.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Rational\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**2 * y)\n",
      " |      x*y**2\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**4 * y)\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(2)\n",
      " |      x\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(3)\n",
      " |      \n",
      " |      >>> (Rational(1, 2)*x).extract_multiplicatively(3)\n",
      " |      x/6\n",
      " |  \n",
      " |  factor(self, *gens, **args)\n",
      " |      See the factor() function in sympy.polys.polytools\n",
      " |  \n",
      " |  fourier_series(self, limits=None)\n",
      " |      Compute fourier sine/cosine series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fourier_series` in sympy.series.fourier\n",
      " |      for more information.\n",
      " |  \n",
      " |  fps(self, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)\n",
      " |      Compute formal power power series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fps` function in sympy.series.formal for\n",
      " |      more information.\n",
      " |  \n",
      " |  gammasimp(self)\n",
      " |      See the gammasimp function in sympy.simplify\n",
      " |  \n",
      " |  getO(self)\n",
      " |      Returns the additive O(..) symbol if there is one, else None.\n",
      " |  \n",
      " |  getn(self)\n",
      " |      Returns the order of the expression.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The order is determined either from the O(...) term. If there\n",
      " |      is no O(...) term, it returns None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import O\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + O(x**2)).getn()\n",
      " |      2\n",
      " |      >>> (1 + x).getn()\n",
      " |  \n",
      " |  integrate(self, *args, **kwargs)\n",
      " |      See the integrate function in sympy.integrals\n",
      " |  \n",
      " |  invert(self, g, *gens, **args)\n",
      " |      Return the multiplicative inverse of ``self`` mod ``g``\n",
      " |      where ``self`` (and ``g``) may be symbolic expressions).\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert\n",
      " |  \n",
      " |  is_algebraic_expr(self, *syms)\n",
      " |      This tests whether a given expression is algebraic or not, in the\n",
      " |      given symbols, syms. When syms is not given, all free symbols\n",
      " |      will be used. The rational function does not have to be in expanded\n",
      " |      or in any kind of canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"algebraic\n",
      " |      expressions\" with symbolic exponents. This is a simple extension to the\n",
      " |      is_rational_function, including rational exponentiation.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sqrt\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> sqrt(1 + x).is_rational_function()\n",
      " |      False\n",
      " |      >>> sqrt(1 + x).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be an algebraic\n",
      " |      expression to become one.\n",
      " |      \n",
      " |      >>> from sympy import exp, factor\n",
      " |      >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)\n",
      " |      >>> a.is_algebraic_expr(x)\n",
      " |      False\n",
      " |      >>> factor(a).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      is_rational_function()\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Algebraic_expression\n",
      " |  \n",
      " |  is_constant(self, *wrt, **flags)\n",
      " |      Return True if self is constant, False if not, or None if\n",
      " |      the constancy could not be determined conclusively.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If an expression has no free symbols then it is a constant. If\n",
      " |      there are free symbols it is possible that the expression is a\n",
      " |      constant, perhaps (but not necessarily) zero. To test such\n",
      " |      expressions, a few strategies are tried:\n",
      " |      \n",
      " |      1) numerical evaluation at two random points. If two such evaluations\n",
      " |      give two different values and the values have a precision greater than\n",
      " |      1 then self is not constant. If the evaluations agree or could not be\n",
      " |      obtained with any precision, no decision is made. The numerical testing\n",
      " |      is done only if ``wrt`` is different than the free symbols.\n",
      " |      \n",
      " |      2) differentiation with respect to variables in 'wrt' (or all free\n",
      " |      symbols if omitted) to see if the expression is constant or not. This\n",
      " |      will not always lead to an expression that is zero even though an\n",
      " |      expression is constant (see added test in test_expr.py). If\n",
      " |      all derivatives are zero then self is constant with respect to the\n",
      " |      given symbols.\n",
      " |      \n",
      " |      3) finding out zeros of denominator expression with free_symbols.\n",
      " |      It will not be constant if there are zeros. It gives more negative\n",
      " |      answers for expression that are not constant.\n",
      " |      \n",
      " |      If neither evaluation nor differentiation can prove the expression is\n",
      " |      constant, None is returned unless two numerical values happened to be\n",
      " |      the same and the flag ``failing_number`` is True -- in that case the\n",
      " |      numerical value will be returned.\n",
      " |      \n",
      " |      If flag simplify=False is passed, self will not be simplified;\n",
      " |      the default is True since self should be simplified before testing.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, Sum, S, pi\n",
      " |      >>> from sympy.abc import a, n, x, y\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> S(2).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, 10)).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant()\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(y)\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(n)\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(x)\n",
      " |      True\n",
      " |      >>> eq = a*cos(x)**2 + a*sin(x)**2 - a\n",
      " |      >>> eq.is_constant()\n",
      " |      True\n",
      " |      >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0\n",
      " |      True\n",
      " |      \n",
      " |      >>> (0**x).is_constant()\n",
      " |      False\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> (x**x).is_constant()\n",
      " |      False\n",
      " |      >>> one = cos(x)**2 + sin(x)**2\n",
      " |      >>> one.is_constant()\n",
      " |      True\n",
      " |      >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1\n",
      " |      True\n",
      " |  \n",
      " |  is_meromorphic(self, x, a)\n",
      " |      This tests whether an expression is meromorphic as\n",
      " |      a function of the given symbol ``x`` at the point ``a``.\n",
      " |      \n",
      " |      This method is intended as a quick test that will return\n",
      " |      None if no decision can be made without simplification or\n",
      " |      more detailed analysis.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import zoo, log, sin, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = 1/x**2 + 1 - 2*x**3\n",
      " |      >>> f.is_meromorphic(x, 0)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      >>> g = x**log(3)\n",
      " |      >>> g.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> g.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> g.is_meromorphic(x, zoo)\n",
      " |      False\n",
      " |      \n",
      " |      >>> h = sin(1/x)*x**2\n",
      " |      >>> h.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> h.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> h.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      Multivalued functions are considered meromorphic when their\n",
      " |      branches are meromorphic. Thus most functions are meromorphic\n",
      " |      everywhere except at essential singularities and branch points.\n",
      " |      In particular, they will be meromorphic also on branch cuts\n",
      " |      except at their endpoints.\n",
      " |      \n",
      " |      >>> log(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> log(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> sqrt(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> sqrt(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |  \n",
      " |  is_polynomial(self, *syms)\n",
      " |      Return True if self is a polynomial in syms and False otherwise.\n",
      " |      \n",
      " |      This checks if self is an exact polynomial in syms.  This function\n",
      " |      returns False for expressions that are \"polynomials\" with symbolic\n",
      " |      exponents.  Thus, you should be able to apply polynomial algorithms to\n",
      " |      expressions for which this returns True, and Poly(expr, \\*syms) should\n",
      " |      work if and only if expr.is_polynomial(\\*syms) returns True. The\n",
      " |      polynomial does not have to be in expanded form.  If no symbols are\n",
      " |      given, all free symbols in the expression will be used.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', polynomial=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Function\n",
      " |      >>> x = Symbol('x')\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial(x)\n",
      " |      True\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial()\n",
      " |      True\n",
      " |      >>> (2**x + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (2**x + 1).is_polynomial(2**x)\n",
      " |      True\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (f(x) + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (f(x) + 1).is_polynomial(f(x))\n",
      " |      True\n",
      " |      >>> (1/f(x) + 1).is_polynomial(f(x))\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', nonnegative=True, integer=True)\n",
      " |      >>> (x**n + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a polynomial to\n",
      " |      become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor, cancel\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)\n",
      " |      >>> a.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      y + 1\n",
      " |      >>> factor(a).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      >>> b = (y**2 + 2*y + 1)/(y + 1)\n",
      " |      >>> b.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> cancel(b)\n",
      " |      y + 1\n",
      " |      >>> cancel(b).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also .is_rational_function()\n",
      " |  \n",
      " |  is_rational_function(self, *syms)\n",
      " |      Test whether function is a ratio of two polynomials in the given\n",
      " |      symbols, syms. When syms is not given, all free symbols will be used.\n",
      " |      The rational function does not have to be in expanded or in any kind of\n",
      " |      canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"rational\n",
      " |      functions\" with symbolic exponents.  Thus, you should be able to call\n",
      " |      .as_numer_denom() and apply polynomial algorithms to the result for\n",
      " |      expressions for which this returns True.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', rational_function=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> (x/y).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x**2).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x/sin(y)).is_rational_function(y)\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', integer=True)\n",
      " |      >>> (x**n + 1).is_rational_function(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a rational function\n",
      " |      to become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)/y\n",
      " |      >>> a.is_rational_function(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      (y + 1)/y\n",
      " |      >>> factor(a).is_rational_function(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also is_algebraic_expr().\n",
      " |  \n",
      " |  leadterm(self, x, logx=None, cdir=0)\n",
      " |      Returns the leading term a*x**b as a tuple (a, b).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1+x+x**2).leadterm(x)\n",
      " |      (1, 0)\n",
      " |      >>> (1/x**2+x+x**2).leadterm(x)\n",
      " |      (1, -2)\n",
      " |  \n",
      " |  limit(self, x, xlim, dir='+')\n",
      " |      Compute limit x->xlim.\n",
      " |  \n",
      " |  lseries(self, x=None, x0=0, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper for series yielding an iterator of the terms of the series.\n",
      " |      \n",
      " |      Note: an infinite series will yield an infinite iterator. The following,\n",
      " |      for exaxmple, will never terminate. It will just keep printing terms\n",
      " |      of the sin(x) series::\n",
      " |      \n",
      " |        for term in sin(x).lseries(x):\n",
      " |            print term\n",
      " |      \n",
      " |      The advantage of lseries() over nseries() is that many times you are\n",
      " |      just interested in the next term in the series (i.e. the first term for\n",
      " |      example), but you do not know how many you should ask for in nseries()\n",
      " |      using the \"n\" parameter.\n",
      " |      \n",
      " |      See also nseries().\n",
      " |  \n",
      " |  normal(self)\n",
      " |      expression -> a/b\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_numer_denom: return ``(a, b)`` instead of ``a/b``\n",
      " |  \n",
      " |  nseries(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper to _eval_nseries if assumptions allow, else to series.\n",
      " |      \n",
      " |      If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is\n",
      " |      called. This calculates \"n\" terms in the innermost expressions and\n",
      " |      then builds up the final series just by \"cross-multiplying\" everything\n",
      " |      out.\n",
      " |      \n",
      " |      The optional ``logx`` parameter can be used to replace any log(x) in the\n",
      " |      returned series with a symbolic value to avoid evaluating log(x) at 0. A\n",
      " |      symbol to use in place of log(x) should be provided.\n",
      " |      \n",
      " |      Advantage -- it's fast, because we do not have to determine how many\n",
      " |      terms we need to calculate in advance.\n",
      " |      \n",
      " |      Disadvantage -- you may end up with less terms than you may have\n",
      " |      expected, but the O(x**n) term appended will always be correct and\n",
      " |      so the result, though perhaps shorter, will also be correct.\n",
      " |      \n",
      " |      If any of those assumptions is not met, this is treated like a\n",
      " |      wrapper to series which will try harder to return the correct\n",
      " |      number of terms.\n",
      " |      \n",
      " |      See also lseries().\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, log, Symbol\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> sin(x).nseries(x, 0, 6)\n",
      " |      x - x**3/6 + x**5/120 + O(x**6)\n",
      " |      >>> log(x+1).nseries(x, 0, 5)\n",
      " |      x - x**2/2 + x**3/3 - x**4/4 + O(x**5)\n",
      " |      \n",
      " |      Handling of the ``logx`` parameter --- in the following example the\n",
      " |      expansion fails since ``sin`` does not have an asymptotic expansion\n",
      " |      at -oo (the limit of log(x) as x approaches 0):\n",
      " |      \n",
      " |      >>> e = sin(log(x))\n",
      " |      >>> e.nseries(x, 0, 6)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      PoleError: ...\n",
      " |      ...\n",
      " |      >>> logx = Symbol('logx')\n",
      " |      >>> e.nseries(x, 0, 6, logx=logx)\n",
      " |      sin(logx)\n",
      " |      \n",
      " |      In the following example, the expansion works but only returns self\n",
      " |      unless the ``logx`` parameter is used:\n",
      " |      \n",
      " |      >>> e = x**y\n",
      " |      >>> e.nseries(x, 0, 2)\n",
      " |      x**y\n",
      " |      >>> e.nseries(x, 0, 2, logx=logx)\n",
      " |      exp(logx*y)\n",
      " |  \n",
      " |  nsimplify(self, constants=(), tolerance=None, full=False)\n",
      " |      See the nsimplify function in sympy.simplify\n",
      " |  \n",
      " |  powsimp(self, *args, **kwargs)\n",
      " |      See the powsimp function in sympy.simplify\n",
      " |  \n",
      " |  primitive(self)\n",
      " |      Return the positive Rational that can be extracted non-recursively\n",
      " |      from every term of self (i.e., self is treated like an Add). This is\n",
      " |      like the as_coeff_Mul() method but primitive always extracts a positive\n",
      " |      Rational (never a negative or a Float).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (3*(x + 1)**2).primitive()\n",
      " |      (3, (x + 1)**2)\n",
      " |      >>> a = (6*x + 2); a.primitive()\n",
      " |      (2, 3*x + 1)\n",
      " |      >>> b = (x/2 + 3); b.primitive()\n",
      " |      (1/2, x + 6)\n",
      " |      >>> (a*b).primitive() == (1, a*b)\n",
      " |      True\n",
      " |  \n",
      " |  radsimp(self, **kwargs)\n",
      " |      See the radsimp function in sympy.simplify\n",
      " |  \n",
      " |  ratsimp(self)\n",
      " |      See the ratsimp function in sympy.simplify\n",
      " |  \n",
      " |  removeO(self)\n",
      " |      Removes the additive O(..) symbol if there is one\n",
      " |  \n",
      " |  round(self, n=None)\n",
      " |      Return x rounded to the given decimal place.\n",
      " |      \n",
      " |      If a complex number would results, apply round to the real\n",
      " |      and imaginary components of the number.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, E, I, S, Number\n",
      " |      >>> pi.round()\n",
      " |      3\n",
      " |      >>> pi.round(2)\n",
      " |      3.14\n",
      " |      >>> (2*pi + E*I).round()\n",
      " |      6 + 3*I\n",
      " |      \n",
      " |      The round method has a chopping effect:\n",
      " |      \n",
      " |      >>> (2*pi + I/10).round()\n",
      " |      6\n",
      " |      >>> (pi/10 + 2*I).round()\n",
      " |      2*I\n",
      " |      >>> (pi/10 + E*I).round(2)\n",
      " |      0.31 + 2.72*I\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      The Python ``round`` function uses the SymPy ``round`` method so it\n",
      " |      will always return a SymPy number (not a Python float or int):\n",
      " |      \n",
      " |      >>> isinstance(round(S(123), -2), Number)\n",
      " |      True\n",
      " |  \n",
      " |  separate(self, deep=False, force=False)\n",
      " |      See the separate function in sympy.simplify\n",
      " |  \n",
      " |  series(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Series expansion of \"self\" around ``x = x0`` yielding either terms of\n",
      " |      the series one by one (the lazy series given when n=None), else\n",
      " |      all the terms at once when n != None.\n",
      " |      \n",
      " |      Returns the series expansion of \"self\" around the point ``x = x0``\n",
      " |      with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).\n",
      " |      \n",
      " |      If ``x=None`` and ``self`` is univariate, the univariate symbol will\n",
      " |      be supplied, otherwise an error will be raised.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      expr : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      x0 : Value\n",
      " |           The value around which ``x`` is calculated. Can be any value\n",
      " |           from ``-oo`` to ``oo``.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |      \n",
      " |      dir : String, optional\n",
      " |            The series-expansion can be bi-directional. If ``dir=\"+\"``,\n",
      " |            then (x->x0+). If ``dir=\"-\", then (x->x0-). For infinite\n",
      " |            ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined\n",
      " |            from the direction of the infinity (i.e., ``dir=\"-\"`` for\n",
      " |            ``oo``).\n",
      " |      \n",
      " |      logx : optional\n",
      " |             It is used to replace any log(x) in the returned series with a\n",
      " |             symbolic value rather than evaluating the actual value.\n",
      " |      \n",
      " |      cdir : optional\n",
      " |             It stands for complex direction, and indicates the direction\n",
      " |             from which the expansion needs to be evaluated.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, exp, tan\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> cos(x).series()\n",
      " |      1 - x**2/2 + x**4/24 + O(x**6)\n",
      " |      >>> cos(x).series(n=4)\n",
      " |      1 - x**2/2 + O(x**4)\n",
      " |      >>> cos(x).series(x, x0=1, n=2)\n",
      " |      cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))\n",
      " |      >>> e = cos(x + exp(y))\n",
      " |      >>> e.series(y, n=2)\n",
      " |      cos(x + 1) - y*sin(x + 1) + O(y**2)\n",
      " |      >>> e.series(x, n=2)\n",
      " |      cos(exp(y)) - x*sin(exp(y)) + O(x**2)\n",
      " |      \n",
      " |      If ``n=None`` then a generator of the series terms will be returned.\n",
      " |      \n",
      " |      >>> term=cos(x).series(n=None)\n",
      " |      >>> [next(term) for i in range(2)]\n",
      " |      [1, -x**2/2]\n",
      " |      \n",
      " |      For ``dir=+`` (default) the series is calculated from the right and\n",
      " |      for ``dir=-`` the series from the left. For smooth functions this\n",
      " |      flag will not alter the results.\n",
      " |      \n",
      " |      >>> abs(x).series(dir=\"+\")\n",
      " |      x\n",
      " |      >>> abs(x).series(dir=\"-\")\n",
      " |      -x\n",
      " |      >>> f = tan(x)\n",
      " |      >>> f.series(x, 2, 6, \"+\")\n",
      " |      tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +\n",
      " |      (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +\n",
      " |      5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +\n",
      " |      2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))\n",
      " |      \n",
      " |      >>> f.series(x, 2, 3, \"-\")\n",
      " |      tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))\n",
      " |      + O((x - 2)**3, (x, 2))\n",
      " |      \n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).series(x, n=8)\n",
      " |      1/x\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr : Expression\n",
      " |          Series expansion of the expression about x0\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      TypeError\n",
      " |          If \"n\" and \"x0\" are infinity objects\n",
      " |      \n",
      " |      PoleError\n",
      " |          If \"x0\" is an infinity object\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  taylor_term(self, n, x, *previous_terms)\n",
      " |      General method for the taylor term.\n",
      " |      \n",
      " |      This method is slow, because it differentiates n-times. Subclasses can\n",
      " |      redefine it to make it faster by using the \"previous_terms\".\n",
      " |  \n",
      " |  together(self, *args, **kwargs)\n",
      " |      See the together function in sympy.polys\n",
      " |  \n",
      " |  transpose(self)\n",
      " |  \n",
      " |  trigsimp(self, **args)\n",
      " |      See the trigsimp function in sympy.simplify\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |      Like ``free_symbols``, but returns the free symbols only if\n",
      " |      they are contained in an expression node.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (x + y).expr_free_symbols # doctest: +SKIP\n",
      " |      {x, y}\n",
      " |      \n",
      " |      If the expression is contained in a non-expression object, do not return\n",
      " |      the free symbols. Compare:\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> t = Tuple(x + y)\n",
      " |      >>> t.expr_free_symbols # doctest: +SKIP\n",
      " |      set()\n",
      " |      >>> t.free_symbols\n",
      " |      {x, y}\n",
      " |  \n",
      " |  is_number\n",
      " |      Returns True if ``self`` has no free symbols and no\n",
      " |      undefined functions (AppliedUndef, to be precise). It will be\n",
      " |      faster than ``if not self.free_symbols``, however, since\n",
      " |      ``is_number`` will fail as soon as it hits a free symbol\n",
      " |      or undefined function.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function, Integral, cos, sin, pi\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> f = Function('f')\n",
      " |      \n",
      " |      >>> x.is_number\n",
      " |      False\n",
      " |      >>> f(1).is_number\n",
      " |      False\n",
      " |      >>> (2*x).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, x)).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, (x, 1, 2))).is_number\n",
      " |      True\n",
      " |      \n",
      " |      Not all numbers are Numbers in the SymPy sense:\n",
      " |      \n",
      " |      >>> pi.is_number, pi.is_Number\n",
      " |      (True, False)\n",
      " |      \n",
      " |      If something is a number it should evaluate to a number with\n",
      " |      real and imaginary parts that are Numbers; the result may not\n",
      " |      be comparable, however, since the real and/or imaginary part\n",
      " |      of the result may not have precision.\n",
      " |      \n",
      " |      >>> cos(1).is_number and cos(1).is_comparable\n",
      " |      True\n",
      " |      \n",
      " |      >>> z = cos(1)**2 + sin(1)**2 - 1\n",
      " |      >>> z.is_number\n",
      " |      True\n",
      " |      >>> z.is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.basic.Basic.is_comparable\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  is_scalar = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace lambda rule, **_\n",
      " |      # Function needs args so we define a property that returns\n",
      " |      # a function that takes args...and then use that function\n",
      " |      # to return the right value\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.function.FunctionClass\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  kind = UndefinedKind\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Abs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "rp=RegularPolygon((0,0),3,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Point2D(3, 0), Point2D(3/2, 3*sqrt(3)/2), Point2D(-3/2, 3*sqrt(3)/2)]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rp.vertices[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "head=Pyramid(2,rp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 27 \\sqrt{3}$"
      ],
      "text/plain": [
       "27*sqrt(3)"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "head.side_area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "body=Prism(rp,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(3, 0, 6\\right)$"
      ],
      "text/plain": [
       "Point3D(3, 0, 6)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "body.vertices[6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Point3D(3, 0, 0),\n",
       " Point3D(3/2, 3*sqrt(3)/2, 0),\n",
       " Point3D(3/2, 3*sqrt(3)/2, 6),\n",
       " Point3D(3, 0, 6)]"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "body.side_polygons[0].vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 27 \\sqrt{3}$"
      ],
      "text/plain": [
       "27*sqrt(3)"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "body.side_polygons[0].area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1436.23523599163$"
      ],
      "text/plain": [
       "1436.23523599163"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(9*(140+180+sqrt(140*180))/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "frum=Frustum(sqrt(6),RegularPolygon((0,0),sqrt(2),4),sqrt(6)/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(\\frac{\\sqrt{2}}{2}, 0, \\frac{\\sqrt{6}}{2}\\right), \\  \\operatorname{Point3D}\\left(0, \\frac{\\sqrt{2}}{2}, \\frac{\\sqrt{6}}{2}\\right), \\  \\operatorname{Point3D}\\left(- \\frac{\\sqrt{2}}{2}, 0, \\frac{\\sqrt{6}}{2}\\right), \\  \\operatorname{Point3D}\\left(0, - \\frac{\\sqrt{2}}{2}, \\frac{\\sqrt{6}}{2}\\right), \\  \\operatorname{Point3D}\\left(\\sqrt{2}, 0, 0\\right), \\  \\operatorname{Point3D}\\left(0, \\sqrt{2}, 0\\right), \\  \\operatorname{Point3D}\\left(- \\sqrt{2}, 0, 0\\right), \\  \\operatorname{Point3D}\\left(0, - \\sqrt{2}, 0\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(sqrt(2)/2, 0, sqrt(6)/2), Point3D(0, sqrt(2)/2, sqrt(6)/2), Point3D(-sqrt(2)/2, 0, sqrt(6)/2), Point3D(0, -sqrt(2)/2, sqrt(6)/2), Point3D(sqrt(2), 0, 0), Point3D(0, sqrt(2), 0), Point3D(-sqrt(2), 0, 0), Point3D(0, -sqrt(2), 0))"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frum.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{6} \\left(\\sqrt{2} + \\sqrt[4]{6} + \\sqrt{3}\\right)}{6}$"
      ],
      "text/plain": [
       "sqrt(6)*(sqrt(2) + 6**(1/4) + sqrt(3))/6"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frum.volume"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{2}$"
      ],
      "text/plain": [
       "sqrt(2)"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frum.bottoms[1].area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "cone=Pyramid(1,Circle((0,0),sqrt(3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\pi$"
      ],
      "text/plain": [
       "pi"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone.volume"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\sqrt{3} \\pi$"
      ],
      "text/plain": [
       "2*sqrt(3)*pi"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cone.side_area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=cone.vertice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 0, 1\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 0, 1)"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "O=Point(0,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(0,sqrt(3),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=Circle(O,sqrt(3)).arbitrary_point(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\sqrt{3} \\cos{\\left(t \\right)}, \\sqrt{3} \\sin{\\left(t \\right)}\\right)$"
      ],
      "text/plain": [
       "Point2D(sqrt(3)*cos(t), sqrt(3)*sin(t))"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(\\frac{3 \\cos^{2}{\\left(t \\right)}}{\\sqrt{\\left(\\sqrt{3} \\sin{\\left(t \\right)} - \\sqrt{3}\\right)^{2} + 12 \\cos^{2}{\\left(t \\right)}} \\sqrt{\\cos^{2}{\\left(t \\right)}}} \\right)}$"
      ],
      "text/plain": [
       "acos(3*cos(t)**2/(sqrt((sqrt(3)*sin(t) - sqrt(3))**2 + 12*cos(t)**2)*sqrt(cos(t)**2)))"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,A,C).angle_between(Plane(O,A,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=trigsimp(cos(_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{3} \\sqrt{\\cos^{2}{\\left(t \\right)}}}{\\sqrt{- 3 \\sin^{2}{\\left(t \\right)} - 2 \\sin{\\left(t \\right)} + 5}}$"
      ],
      "text/plain": [
       "sqrt(3)*sqrt(cos(t)**2)/sqrt(-3*sin(t)**2 - 2*sin(t) + 5)"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{2 n \\pi + \\operatorname{atan}{\\left(\\frac{\\sqrt{2}}{4} \\right)} + \\pi\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\} \\cup \\left\\{2 n \\pi - \\operatorname{atan}{\\left(\\frac{\\sqrt{2}}{4} \\right)} + 2 \\pi\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\}$"
      ],
      "text/plain": [
       "Union(ImageSet(Lambda(_n, 2*_n*pi + atan(sqrt(2)/4) + pi), Integers), ImageSet(Lambda(_n, 2*_n*pi - atan(sqrt(2)/4) + 2*pi), Integers))"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(simplify(answer)-1/sqrt(2),t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{2 \\sqrt{6}}{3}, - \\frac{\\sqrt{3}}{3}\\right)$"
      ],
      "text/plain": [
       "Point2D(2*sqrt(6)/3, -sqrt(3)/3)"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.subs(t,-atan(1/sqrt(8)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [],
   "source": [
    "C1=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\pi}{4}$"
      ],
      "text/plain": [
       "pi/4"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,A,C1).angle_between(Plane(O,A,C1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/huang/anaconda3/lib/python3.9/site-packages/sympy/geometry/point.py:312: UserWarning: Dimension of (2*sqrt(6)/3, -sqrt(3)/3) needs to be changed from 2 to 3.\n",
      "  return [Point(i, **kwargs) for i in points]\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\sqrt{2}$"
      ],
      "text/plain": [
       "2*sqrt(2)"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.distance(C1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{2}$"
      ],
      "text/plain": [
       "sqrt(2)"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P.distance(Line(A,C1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "O.distance(Line(A,C1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\sqrt{2}$"
      ],
      "text/plain": [
       "-sqrt(2)"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Triangle(O,A,C1).area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_f=sqrt(5**2-x**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_g=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 64 \\sqrt{6}$"
      ],
      "text/plain": [
       "64*sqrt(6)"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "integrate(expr_f**2-expr_g**2,(x,-sqrt(24),sqrt(24)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "prm=Cube([3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(0, 0, 0\\right), \\  \\operatorname{Point3D}\\left(3, 0, 0\\right), \\  \\operatorname{Point3D}\\left(3, 4, 0\\right), \\  \\operatorname{Point3D}\\left(0, 4, 0\\right), \\  \\operatorname{Point3D}\\left(0, 0, 5\\right), \\  \\operatorname{Point3D}\\left(3, 0, 5\\right), \\  \\operatorname{Point3D}\\left(3, 4, 5\\right), \\  \\operatorname{Point3D}\\left(0, 4, 5\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(0, 0, 0), Point3D(3, 0, 0), Point3D(3, 4, 0), Point3D(0, 4, 0), Point3D(0, 0, 5), Point3D(3, 0, 5), Point3D(3, 4, 5), Point3D(0, 4, 5))"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prm.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B,C,D,A1,B1,C1,D1=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [],
   "source": [
    "thn=Tetrahedron(A,C,D,A1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 50 \\pi$"
      ],
      "text/plain": [
       "50*pi"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "thn.circumsphere.surface_area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{5 \\sqrt{2}}{2}$"
      ],
      "text/plain": [
       "5*sqrt(2)/2"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "thn.circumsphere.radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=Triangle(sss=(sqrt(6),sqrt(6),sqrt(8)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Point2D(0, 0), Point2D(sqrt(6), 0), Point2D(2*sqrt(6)/3, 4*sqrt(3)/3))"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B,C=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=Point(sqrt(6)/2,-sqrt(3/S(8)),sqrt(9/S(8)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{\\sqrt{6}}{2}, - \\frac{\\sqrt{6}}{4}, \\frac{3 \\sqrt{2}}{4}\\right)$"
      ],
      "text/plain": [
       "Point3D(sqrt(6)/2, -sqrt(6)/4, 3*sqrt(2)/4)"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "points_to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [],
   "source": [
    "from geometry3D.utils import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Point3D(0, 0, 0),\n",
       " Point3D(sqrt(6), 0, 0),\n",
       " Point3D(2*sqrt(6)/3, 4*sqrt(3)/3, 0)]"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points_to_3d(Polygon(A,B,C).vertices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Point3D(0, 0, 0), Point3D(sqrt(6), 0, 0), Point3D(2*sqrt(6)/3, 4*sqrt(3)/3, 0)]\n"
     ]
    }
   ],
   "source": [
    "thn=Tetrahedron(P,Polygon(A,B,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Sphere}\\left(\\operatorname{Point3D}\\left(\\frac{\\sqrt{6}}{2}, \\frac{\\sqrt{3}}{2}, \\frac{1}{2}\\right), \\frac{\\sqrt{10}}{2}\\right)$"
      ],
      "text/plain": [
       "Sphere(Point3D(sqrt(6)/2, sqrt(3)/2, 1/2), sqrt(10)/2)"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "thn.circumsphere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=x**2*(1-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} \\cdot \\left(1 - x\\right)$"
      ],
      "text/plain": [
       "x**2*(1 - x)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1,x2=symbols(\"x1:3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x_{1}^{2} \\cdot \\left(1 - x_{1}\\right) + x_{2}^{2} \\cdot \\left(1 - x_{2}\\right) - 2 \\left(\\frac{x_{1}}{2} + \\frac{x_{2}}{2}\\right)^{2} \\left(- \\frac{x_{1}}{2} - \\frac{x_{2}}{2} + 1\\right)$"
      ],
      "text/plain": [
       "x1**2*(1 - x1) + x2**2*(1 - x2) - 2*(x1/2 + x2/2)**2*(-x1/2 - x2/2 + 1)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,x1)+expr.subs(x,x2)-2*expr.subs(x,(x1+x2)/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\left(x_{1} - x_{2}\\right)^{2} \\cdot \\left(3 x_{1} + 3 x_{2} - 2\\right)}{4}$"
      ],
      "text/plain": [
       "-(x1 - x2)**2*(3*x1 + 3*x2 - 2)/4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=Triangle(sss=(1+sqrt(2),1+sqrt(2),2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__and__',\n",
       " '__annotations__',\n",
       " '__class__',\n",
       " '__cmp__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getnewargs__',\n",
       " '__getstate__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__or__',\n",
       " '__pow__',\n",
       " '__radd__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmul__',\n",
       " '__rsub__',\n",
       " '__rtruediv__',\n",
       " '__setattr__',\n",
       " '__setstate__',\n",
       " '__sizeof__',\n",
       " '__slots__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__sympy__',\n",
       " '__weakref__',\n",
       " '__xor__',\n",
       " '_args',\n",
       " '_assumptions',\n",
       " '_boundary',\n",
       " '_compare_pretty',\n",
       " '_complement',\n",
       " '_constructor_postprocessor_mapping',\n",
       " '_contains',\n",
       " '_do_eq_sympify',\n",
       " '_do_poly_distance',\n",
       " '_eval_derivative_n_times',\n",
       " '_eval_evalf',\n",
       " '_eval_is_subset',\n",
       " '_eval_is_superset',\n",
       " '_eval_powerset',\n",
       " '_eval_rewrite',\n",
       " '_eval_subs',\n",
       " '_evalf',\n",
       " '_exec_constructor_postprocessors',\n",
       " '_explicit_class_assumptions',\n",
       " '_has',\n",
       " '_hashable_content',\n",
       " '_inf',\n",
       " '_infimum_key',\n",
       " '_isright',\n",
       " '_kind',\n",
       " '_measure',\n",
       " '_mhash',\n",
       " '_prop_handler',\n",
       " '_recursive_call',\n",
       " '_repr_disabled',\n",
       " '_repr_latex_',\n",
       " '_repr_png_',\n",
       " '_repr_svg_',\n",
       " '_rewrite',\n",
       " '_sage_',\n",
       " '_sorted_args',\n",
       " '_subs',\n",
       " '_sup',\n",
       " '_svg',\n",
       " '_symmetric_difference',\n",
       " '_sympy_',\n",
       " '_to_mpmath',\n",
       " '_xreplace',\n",
       " 'altitudes',\n",
       " 'ambient_dimension',\n",
       " 'angles',\n",
       " 'arbitrary_point',\n",
       " 'area',\n",
       " 'args',\n",
       " 'as_content_primitive',\n",
       " 'as_dummy',\n",
       " 'assumptions0',\n",
       " 'atoms',\n",
       " 'bisectors',\n",
       " 'boundary',\n",
       " 'bounds',\n",
       " 'canonical_variables',\n",
       " 'centroid',\n",
       " 'circumcenter',\n",
       " 'circumcircle',\n",
       " 'circumradius',\n",
       " 'class_key',\n",
       " 'closure',\n",
       " 'compare',\n",
       " 'complement',\n",
       " 'contains',\n",
       " 'copy',\n",
       " 'could_extract_minus_sign',\n",
       " 'count',\n",
       " 'count_ops',\n",
       " 'cut_section',\n",
       " 'default_assumptions',\n",
       " 'distance',\n",
       " 'doit',\n",
       " 'dummy_eq',\n",
       " 'encloses',\n",
       " 'encloses_point',\n",
       " 'equals',\n",
       " 'eulerline',\n",
       " 'evalf',\n",
       " 'excenters',\n",
       " 'expr_free_symbols',\n",
       " 'exradii',\n",
       " 'find',\n",
       " 'first_moment_of_area',\n",
       " 'free_symbols',\n",
       " 'fromiter',\n",
       " 'func',\n",
       " 'has',\n",
       " 'has_free',\n",
       " 'incenter',\n",
       " 'incircle',\n",
       " 'inf',\n",
       " 'inradius',\n",
       " 'interior',\n",
       " 'intersect',\n",
       " 'intersection',\n",
       " 'is_Add',\n",
       " 'is_AlgebraicNumber',\n",
       " 'is_Atom',\n",
       " 'is_Boolean',\n",
       " 'is_Complement',\n",
       " 'is_ComplexRegion',\n",
       " 'is_Derivative',\n",
       " 'is_Dummy',\n",
       " 'is_EmptySet',\n",
       " 'is_Equality',\n",
       " 'is_FiniteSet',\n",
       " 'is_Float',\n",
       " 'is_Function',\n",
       " 'is_Indexed',\n",
       " 'is_Integer',\n",
       " 'is_Intersection',\n",
       " 'is_Interval',\n",
       " 'is_MatAdd',\n",
       " 'is_MatMul',\n",
       " 'is_Matrix',\n",
       " 'is_Mul',\n",
       " 'is_Not',\n",
       " 'is_Number',\n",
       " 'is_NumberSymbol',\n",
       " 'is_Order',\n",
       " 'is_Piecewise',\n",
       " 'is_Point',\n",
       " 'is_Poly',\n",
       " 'is_Pow',\n",
       " 'is_ProductSet',\n",
       " 'is_Rational',\n",
       " 'is_Relational',\n",
       " 'is_Symbol',\n",
       " 'is_Union',\n",
       " 'is_UniversalSet',\n",
       " 'is_Vector',\n",
       " 'is_Wild',\n",
       " 'is_algebraic',\n",
       " 'is_antihermitian',\n",
       " 'is_closed',\n",
       " 'is_commutative',\n",
       " 'is_comparable',\n",
       " 'is_complex',\n",
       " 'is_composite',\n",
       " 'is_convex',\n",
       " 'is_disjoint',\n",
       " 'is_empty',\n",
       " 'is_equilateral',\n",
       " 'is_even',\n",
       " 'is_extended_negative',\n",
       " 'is_extended_nonnegative',\n",
       " 'is_extended_nonpositive',\n",
       " 'is_extended_nonzero',\n",
       " 'is_extended_positive',\n",
       " 'is_extended_real',\n",
       " 'is_finite',\n",
       " 'is_finite_set',\n",
       " 'is_hermitian',\n",
       " 'is_hypergeometric',\n",
       " 'is_imaginary',\n",
       " 'is_infinite',\n",
       " 'is_integer',\n",
       " 'is_interval',\n",
       " 'is_irrational',\n",
       " 'is_isosceles',\n",
       " 'is_iterable',\n",
       " 'is_negative',\n",
       " 'is_noninteger',\n",
       " 'is_nonnegative',\n",
       " 'is_nonpositive',\n",
       " 'is_nonzero',\n",
       " 'is_number',\n",
       " 'is_odd',\n",
       " 'is_open',\n",
       " 'is_polar',\n",
       " 'is_positive',\n",
       " 'is_prime',\n",
       " 'is_proper_subset',\n",
       " 'is_proper_superset',\n",
       " 'is_rational',\n",
       " 'is_real',\n",
       " 'is_right',\n",
       " 'is_scalene',\n",
       " 'is_similar',\n",
       " 'is_subset',\n",
       " 'is_superset',\n",
       " 'is_symbol',\n",
       " 'is_transcendental',\n",
       " 'is_zero',\n",
       " 'isdisjoint',\n",
       " 'issubset',\n",
       " 'issuperset',\n",
       " 'kind',\n",
       " 'match',\n",
       " 'matches',\n",
       " 'measure',\n",
       " 'medial',\n",
       " 'medians',\n",
       " 'n',\n",
       " 'nine_point_circle',\n",
       " 'orthocenter',\n",
       " 'parameter_value',\n",
       " 'perimeter',\n",
       " 'plot_interval',\n",
       " 'polar_second_moment_of_area',\n",
       " 'powerset',\n",
       " 'rcall',\n",
       " 'refine',\n",
       " 'reflect',\n",
       " 'replace',\n",
       " 'rewrite',\n",
       " 'rotate',\n",
       " 'scale',\n",
       " 'second_moment_of_area',\n",
       " 'section_modulus',\n",
       " 'sides',\n",
       " 'simplify',\n",
       " 'sort_key',\n",
       " 'subs',\n",
       " 'sup',\n",
       " 'symmetric_difference',\n",
       " 'translate',\n",
       " 'union',\n",
       " 'vertices',\n",
       " 'xreplace']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\sqrt{-1 + \\sqrt{2}} \\left(\\sqrt{2} + 2\\right)}{\\sqrt{2} + \\sqrt{2 \\sqrt{2} + 3} + 3}$"
      ],
      "text/plain": [
       "2*sqrt(-1 + sqrt(2))*(sqrt(2) + 2)/(sqrt(2) + sqrt(2*sqrt(2) + 3) + 3)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.inradius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{-1 + \\sqrt{2}}$"
      ],
      "text/plain": [
       "sqrt(-1 + sqrt(2))"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nsimplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "r=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{-1 + \\sqrt{2}}$"
      ],
      "text/plain": [
       "sqrt(-1 + sqrt(2))"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "h=sqrt(2+sqrt(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{2 + 2 \\sqrt{2}}$"
      ],
      "text/plain": [
       "sqrt(2 + 2*sqrt(2))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{- \\sqrt{-1 + \\sqrt{2}} + \\sqrt{2 + 2 \\sqrt{2}}}{\\sqrt{-1 + \\sqrt{2}}}$"
      ],
      "text/plain": [
       "(-sqrt(-1 + sqrt(2)) + sqrt(2 + 2*sqrt(2)))/sqrt(-1 + sqrt(2))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(h-r)/r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1 + \\sqrt{2}$"
      ],
      "text/plain": [
       "1 + sqrt(2)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nsimplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,h=symbols(\"a,h\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyd=Pyramid(h,RegularPolygon((0,0),a,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(0, 0, h\\right), \\  \\operatorname{Point3D}\\left(a, 0, 0\\right), \\  \\operatorname{Point3D}\\left(0, a, 0\\right), \\  \\operatorname{Point3D}\\left(- a, 0, 0\\right), \\  \\operatorname{Point3D}\\left(0, - a, 0\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(0, 0, h), Point3D(a, 0, 0), Point3D(0, a, 0), Point3D(-a, 0, 0), Point3D(0, -a, 0))"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pyd.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "P,C,D,A,B=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( a h, \\  a h, \\  a^{2}\\right)$"
      ],
      "text/plain": [
       "(a*h, a*h, a**2)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,C,D).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\operatorname{asin}{\\left(\\frac{a^{2}}{\\sqrt{a^{4} + 2 a^{2} h^{2}}} \\right)}$"
      ],
      "text/plain": [
       "-asin(a**2/sqrt(a**4 + 2*a**2*h**2))"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,C,D).angle_between(Line(P,Point(0,0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{a^{2}}{\\sqrt{a^{4} + 2 a^{2} h^{2}}}$"
      ],
      "text/plain": [
       "-a**2/sqrt(a**4 + 2*a**2*h**2)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nsimplify(sin(_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{a}{\\sqrt{a^{2} + 2 h^{2}}}$"
      ],
      "text/plain": [
       "-a/sqrt(a**2 + 2*h**2)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "r,R=symbols(\"r,R\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{a \\left(h - r\\right)}{\\sqrt{a^{2} + 2 h^{2}}} + r$"
      ],
      "text/plain": [
       "-a*(h - r)/sqrt(a**2 + 2*h**2) + r"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r-(h-r)*a/(sqrt(a**2+2*h**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{a h}{a + \\sqrt{a^{2} + 2 h^{2}}}\\right\\}$"
      ],
      "text/plain": [
       "{a*h/(a + sqrt(a**2 + 2*h**2))}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "eq=Eq(x+1,(x-1)*sqrt(2*x+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x + 1 = \\left(x - 1\\right) \\sqrt{2 x + 1}$"
      ],
      "text/plain": [
       "Eq(x + 1, (x - 1)*sqrt(2*x + 1))"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\left(x - 1\\right)^{2} \\cdot \\left(2 x + 1\\right) + \\left(x + 1\\right)^{2}$"
      ],
      "text/plain": [
       "-(x - 1)**2*(2*x + 1) + (x + 1)**2"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify_equation(eq,square=True,expr=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 2 x^{3} + 4 x^{2} + 2 x$"
      ],
      "text/plain": [
       "-2*x**3 + 4*x**2 + 2*x"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 2 x \\left(x^{2} - 2 x - 1\\right)$"
      ],
      "text/plain": [
       "-2*x*(x**2 - 2*x - 1)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{0, 1 - \\sqrt{2}, 1 + \\sqrt{2}\\right\\}$"
      ],
      "text/plain": [
       "{0, 1 - sqrt(2), 1 + sqrt(2)}"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Line3D}\\left(\\operatorname{Point3D}\\left(0, 0, 0\\right), \\operatorname{Point3D}\\left(1, 2, 3\\right)\\right)$"
      ],
      "text/plain": [
       "Line3D(Point3D(0, 0, 0), Point3D(1, 2, 3))"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line((0,0,0),direction_ratio=(1,2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport geometry3D.sphere\n",
    "from geometry3D.sphere import Sphere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyd=Pyramid(sqrt(6),RegularPolygon((0,0),sqrt(3),3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "insphere=pyd.inscribed_sphere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{6} \\pi}{8}$"
      ],
      "text/plain": [
       "sqrt(6)*pi/8"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "insphere.volume"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3 \\pi}{2}$"
      ],
      "text/plain": [
       "3*pi/2"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "insphere.surface_area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- 4 \\sqrt{3} + 6 \\sqrt{2}, 4 \\sqrt{3} + 6 \\sqrt{2}\\right\\}$"
      ],
      "text/plain": [
       "{-4*sqrt(3) + 6*sqrt(2), 4*sqrt(3) + 6*sqrt(2)}"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(x**2-(3/sqrt(8)*x-1)**2-2,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer1,answer2=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1.55707814396306$"
      ],
      "text/plain": [
       "1.55707814396306"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(answer1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 15.4134846045141$"
      ],
      "text/plain": [
       "15.4134846045141"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(answer2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.geometry.polygon.RegularPolygon"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(RegularPolygon((0,0),1/sqrt(3),3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "prm=Prism(RegularPolygon((0,0),1/sqrt(3),3),1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B,C,A1,B1,C1=prm.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=(A+A1)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=(B+B1)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "F=(B+C)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(- \\frac{\\sqrt{5}}{10} \\right)}$"
      ],
      "text/plain": [
       "acos(-sqrt(5)/10)"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line(D,F).angle_between(Line(E,C1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(0, 0, \\sqrt{6}\\right), \\  \\operatorname{Point3D}\\left(\\sqrt{3}, 0, 0\\right), \\  \\operatorname{Point3D}\\left(- \\frac{\\sqrt{3}}{2}, \\frac{3}{2}, 0\\right), \\  \\operatorname{Point3D}\\left(- \\frac{\\sqrt{3}}{2}, - \\frac{3}{2}, 0\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(0, 0, sqrt(6)), Point3D(sqrt(3), 0, 0), Point3D(-sqrt(3)/2, 3/2, 0), Point3D(-sqrt(3)/2, -3/2, 0))"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pyd.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B,C,D=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "M=(A+C)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "N=(A+D)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(- \\frac{1}{6} \\right)}$"
      ],
      "text/plain": [
       "acos(-1/6)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line(B,M).angle_between(Line(C,N))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "cone=Cone(1,Circle((0,0),1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "S=cone.vertice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=symbols(\"t\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "p=cone.bottom.arbitrary_point(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\cos{\\left(t \\right)}, \\sin{\\left(t \\right)}\\right)$"
      ],
      "text/plain": [
       "Point2D(cos(t), sin(t))"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=p.subs(t,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=p.subs(t,pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(1, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(1, 0)"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(-1, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(-1, 0)"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=p.subs(t,pi/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(\\frac{\\sqrt{6}}{4} \\right)}$"
      ],
      "text/plain": [
       "acos(sqrt(6)/4)"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line(S,A).angle_between(Line(B,D))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{Point2D(sqrt(5)/5, 3*sqrt(5)/5): acos(sqrt(10)/10),\n",
       " Point2D(0, 0): acos(sqrt(10)/10),\n",
       " Point2D(sqrt(5), 0): acos(4/5)}"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Triangle(sss=(sqrt(5),sqrt(5),sqrt(2))).angles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "cube=Cube(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "p,q=symbols(\"p,q\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "D,A,B,C,D1,A1,B1,C1=cube.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=D*(1-p)+D1*(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 0, p\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 0, p)"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "F=B1*q+C1*(1-q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(q, 1, 1\\right)$"
      ],
      "text/plain": [
       "Point3D(q, 1, 1)"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{asin}{\\left(\\frac{q - 1}{\\sqrt{\\left(q - 1\\right)^{2} + \\left(p q - p + 1\\right)^{2} + 1}} \\right)}$"
      ],
      "text/plain": [
       "asin((q - 1)/sqrt((q - 1)**2 + (p*q - p + 1)**2 + 1))"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(E,F,B).angle_between(Line(A,A1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( -1, \\  p \\left(q - 1\\right) + 1, \\  q - 1\\right)$"
      ],
      "text/plain": [
       "(-1, p*(q - 1) + 1, q - 1)"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B,E,F).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\pi}{6}$"
      ],
      "text/plain": [
       "-pi/6"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B,B1,D).angle_between(Line(B1,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyd=Pyramid(sqrt(3),RegularPolygon((0,0),1,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "P,B,E,D,A=pyd.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 0, \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 0, sqrt(3))"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(-1, 0, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(-1, 0, 0)"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=Point(-1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(1, 0, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(1, 0, 0)"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, -1, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(0, -1, 0)"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( - 2 \\sqrt{3}, \\  0, \\  2\\right)$"
      ],
      "text/plain": [
       "(-2*sqrt(3), 0, 2)"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,C,D).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{asin}{\\left(\\frac{\\sqrt{6}}{4} \\right)}$"
      ],
      "text/plain": [
       "asin(sqrt(6)/4)"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,C,D).angle_between(Line(B,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{10}}{4}$"
      ],
      "text/plain": [
       "sqrt(10)/4"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cos(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(0,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "p=Point(cos(t),sin(t),2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=p.subs(t,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "D1=p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "A1=Point(2*cos(t),2*sin(t),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=A1.subs(t,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{asin}{\\left(\\frac{2 \\sin{\\left(t \\right)}}{\\sqrt{\\left(2 \\cos{\\left(t \\right)} - 1\\right)^{2} + 4 \\sin^{2}{\\left(t \\right)} + 4}} \\right)}$"
      ],
      "text/plain": [
       "asin(2*sin(t)/sqrt((2*cos(t) - 1)**2 + 4*sin(t)**2 + 4))"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(A,B,D).angle_between(Line(D,A1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( \\frac{\\sqrt{195}}{14}, \\  - \\frac{1}{14}\\right), \\left( \\frac{\\sqrt{3}}{2}, \\  \\frac{1}{2}\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(sqrt(195)/14, -1/14), (sqrt(3)/2, 1/2)}"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nonlinsolve([sin(t)**2+cos(t)**2-1,sin(Plane(A,B,D).angle_between(Line(D,A1)))-sqrt(3/S(7))],[sin(t),cos(t)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1.64228577668042$"
      ],
      "text/plain": [
       "1.64228577668042"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(2*atan(sqrt(195)/13))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyd=Prism(RegularPolygon((0,0),4/sqrt(3),3),3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [],
   "source": [
    "A1,B1,C1,A,B,C=pyd.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=(A+C)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "F=(B+C)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=(B1+C1)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(C1,E,F).angle_between(Line(A,D))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\operatorname{asin}{\\left(\\frac{3 \\sqrt{13}}{26} \\right)}$"
      ],
      "text/plain": [
       "-asin(3*sqrt(13)/26)"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(C1,E,F).angle_between(Line(E,D))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( -3, \\  - 3 \\sqrt{3}, \\  2 \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "(-3, -3*sqrt(3), 2*sqrt(3))"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(C1,E,F).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Cube}\\left(\\operatorname{Point3D}\\left(0, 0, 0\\right), \\operatorname{Point3D}\\left(1, 0, 0\\right), \\operatorname{Point3D}\\left(1, 1, 0\\right), \\operatorname{Point3D}\\left(0, 1, 0\\right), \\operatorname{Point3D}\\left(0, 0, 1\\right), \\operatorname{Point3D}\\left(1, 0, 1\\right), \\operatorname{Point3D}\\left(1, 1, 1\\right), \\operatorname{Point3D}\\left(0, 1, 1\\right)\\right)$"
      ],
      "text/plain": [
       "Cube(Point3D(0, 0, 0), Point3D(1, 0, 0), Point3D(1, 1, 0), Point3D(0, 1, 0), Point3D(0, 0, 1), Point3D(1, 0, 1), Point3D(1, 1, 1), Point3D(0, 1, 1))"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cube"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "B,C,D,A,B1,C1,D1,A1=cube.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=(A1+C)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\pi}{3}$"
      ],
      "text/plain": [
       "2*pi/3"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B,D,A).angle_between(Plane(B,D,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{1}{2}, \\frac{1}{2}, \\frac{1}{2}\\right)$"
      ],
      "text/plain": [
       "Point3D(1/2, 1/2, 1/2)"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D-B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 1, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 1, 0)"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A-B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(1, 0, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(1, 0, 0)"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C-B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( - \\frac{1}{2}, \\  0, \\  \\frac{1}{2}\\right)$"
      ],
      "text/plain": [
       "(-1/2, 0, 1/2)"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(A,B,D).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 0, \\  \\frac{1}{2}, \\  - \\frac{1}{2}\\right)$"
      ],
      "text/plain": [
       "(0, 1/2, -1/2)"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(C,B,D).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(0, 0, 0\\right), \\  \\operatorname{Point3D}\\left(1, 0, 0\\right), \\  \\operatorname{Point3D}\\left(1, 1, 0\\right), \\  \\operatorname{Point3D}\\left(0, 1, 0\\right), \\  \\operatorname{Point3D}\\left(0, 0, 1\\right), \\  \\operatorname{Point3D}\\left(1, 0, 1\\right), \\  \\operatorname{Point3D}\\left(1, 1, 1\\right), \\  \\operatorname{Point3D}\\left(0, 1, 1\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(0, 0, 0), Point3D(1, 0, 0), Point3D(1, 1, 0), Point3D(0, 1, 0), Point3D(0, 0, 1), Point3D(1, 0, 1), Point3D(1, 1, 1), Point3D(0, 1, 1))"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cube.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [],
   "source": [
    "D,A,B,C,D1,A1,B1,C1=[2*point for point in _]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 0, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 0, 0)"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(2, 0, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(2, 0, 0)"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "A1=(D1+A1)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(1, 0, 2\\right)$"
      ],
      "text/plain": [
       "Point3D(1, 0, 2)"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [],
   "source": [
    "B1=(D1+B1)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [],
   "source": [
    "C1=(D1+C1)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(- \\frac{1}{5} \\right)}$"
      ],
      "text/plain": [
       "acos(-1/5)"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B,B1,A).angle_between(Plane(B,B1,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\sqrt{6}}{5}$"
      ],
      "text/plain": [
       "2*sqrt(6)/5"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 4, \\  0, \\  2\\right)$"
      ],
      "text/plain": [
       "(4, 0, 2)"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B,B1,A).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 0, \\  -4, \\  -2\\right)$"
      ],
      "text/plain": [
       "(0, -4, -2)"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B,B1,C).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [],
   "source": [
    "C,A,B,D,P,A1,B1,D1=cube.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [],
   "source": [
    "M=(A+P)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{1}{2}, 0, \\frac{1}{2}\\right)$"
      ],
      "text/plain": [
       "Point3D(1/2, 0, 1/2)"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [],
   "source": [
    "N=(C+B)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{1}{2}, \\frac{1}{2}, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(1/2, 1/2, 0)"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( - \\frac{1}{4}, \\  - \\frac{1}{4}, \\  - \\frac{1}{4}\\right)$"
      ],
      "text/plain": [
       "(-1/4, -1/4, -1/4)"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(M,N,A).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( - \\frac{1}{4}, \\  \\frac{1}{4}, \\  \\frac{1}{4}\\right)$"
      ],
      "text/plain": [
       "(-1/4, 1/4, 1/4)"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "Plane(M,N,C).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(- \\frac{1}{3} \\right)}$"
      ],
      "text/plain": [
       "acos(-1/3)"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(M,N,C).angle_between(Plane(M,N,A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(- \\frac{1}{2}, 0, \\frac{1}{2}\\right)$"
      ],
      "text/plain": [
       "Point3D(-1/2, 0, 1/2)"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M-A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(- \\frac{1}{2}, \\frac{1}{2}, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(-1/2, 1/2, 0)"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N-A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=Point(0,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=Point(1,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(0,sqrt(3),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=Point(0,0,sqrt(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=-C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( -3, \\  - \\sqrt{3}, \\  - \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "(-3, -sqrt(3), -sqrt(3))"
      ]
     },
     "execution_count": 250,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B,C,E).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 0, \\  0, \\  - 2 \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "(0, 0, -2*sqrt(3))"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B,C,A).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(\\frac{\\sqrt{5}}{5} \\right)}$"
      ],
      "text/plain": [
       "acos(sqrt(5)/5)"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B,C,E).angle_between(Plane(B,C,A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\operatorname{acos}{\\left(\\frac{\\sqrt{5}}{5} \\right)}\n"
     ]
    }
   ],
   "source": [
    "print(latex(_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [],
   "source": [
    "D1,A1,E,C1,D,A,F,C=cube.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [],
   "source": [
    "B1=2*E-A1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(1, 2, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(1, 2, 0)"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(- \\frac{\\sqrt{6}}{3} \\right)}$"
      ],
      "text/plain": [
       "acos(-sqrt(6)/3)"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(C,E,D1).angle_between(Plane(C,E,B1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [],
   "source": [
    "cubo=Cube([2,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(0, 0, 0\\right), \\  \\operatorname{Point3D}\\left(2, 0, 0\\right), \\  \\operatorname{Point3D}\\left(2, 2, 0\\right), \\  \\operatorname{Point3D}\\left(0, 2, 0\\right), \\  \\operatorname{Point3D}\\left(0, 0, 3\\right), \\  \\operatorname{Point3D}\\left(2, 0, 3\\right), \\  \\operatorname{Point3D}\\left(2, 2, 3\\right), \\  \\operatorname{Point3D}\\left(0, 2, 3\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(0, 0, 0), Point3D(2, 0, 0), Point3D(2, 2, 0), Point3D(0, 2, 0), Point3D(0, 0, 3), Point3D(2, 0, 3), Point3D(2, 2, 3), Point3D(0, 2, 3))"
      ]
     },
     "execution_count": 260,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cubo.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [],
   "source": [
    "D,A,B,C,D1,A1,B1,C1=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=(B+C)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 263,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(C1,D,E).angle_between(Line(B,D1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(\\frac{2}{7} \\right)}$"
      ],
      "text/plain": [
       "acos(2/7)"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(C1,D,E).angle_between(Plane(A,B,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3 \\sqrt{5}}{2}$"
      ],
      "text/plain": [
       "3*sqrt(5)/2"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(tan(_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{18}{7}$"
      ],
      "text/plain": [
       "18/7"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(C1,D,E).distance(A1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 6, \\  -3, \\  2\\right)$"
      ],
      "text/plain": [
       "(6, -3, 2)"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(C1,D,E).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [],
   "source": [
    "H=Point(0,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=Point(3/S(2),0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(1/S(2),sqrt(3),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=Point(0,sqrt(3)/2,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(cos(t)/2,0,sin(t)/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{\\cos{\\left(t \\right)}}{2}, 0, \\frac{\\sin{\\left(t \\right)}}{2}\\right)$"
      ],
      "text/plain": [
       "Point3D(cos(t)/2, 0, sin(t)/2)"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "pyd=Pyramid(B,Polygon(H,C,A,D))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(\\frac{\\sin^{2}{\\left(t \\right)}}{4 \\sqrt{\\left(- \\frac{\\sqrt{3} \\cos{\\left(t \\right)}}{4} - \\frac{\\sqrt{3}}{4}\\right)^{2} + \\frac{\\sin^{2}{\\left(t \\right)}}{4}} \\sqrt{\\sin^{2}{\\left(t \\right)}}} \\right)}$"
      ],
      "text/plain": [
       "acos(sin(t)**2/(4*sqrt((-sqrt(3)*cos(t)/4 - sqrt(3)/4)**2 + sin(t)**2/4)*sqrt(sin(t)**2)))"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(H,C,B).angle_between(Plane(D,A,B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(\\frac{1}{3} \\right)}$"
      ],
      "text/plain": [
       "acos(1/3)"
      ]
     },
     "execution_count": 290,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(H,C,B.subs(t,atan(sqrt(15)))).angle_between(Plane(D,A,B.subs(t,atan(sqrt(15)))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{2 n \\pi + \\operatorname{atan}{\\left(\\sqrt{15} \\right)}\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\} \\cup \\left\\{2 n \\pi - \\operatorname{atan}{\\left(\\sqrt{15} \\right)} + 2 \\pi\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\}$"
      ],
      "text/plain": [
       "Union(ImageSet(Lambda(_n, 2*_n*pi - atan(sqrt(15)) + 2*pi), Integers), ImageSet(Lambda(_n, 2*_n*pi + atan(sqrt(15))), Integers))"
      ]
     },
     "execution_count": 282,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(simplify(cos(_)-1/S(3)),t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [],
   "source": [
    "tetram=Tetrahedron(B.subs(t,atan(sqrt(15))),D,C,H)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{15}}{8}$"
      ],
      "text/plain": [
       "sqrt(15)/8"
      ]
     },
     "execution_count": 302,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tetram.height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{\\cos{\\left(t \\right)}}{2}, - \\frac{\\sqrt{3}}{2}, \\frac{\\sin{\\left(t \\right)}}{2}\\right)$"
      ],
      "text/plain": [
       "Point3D(cos(t)/2, -sqrt(3)/2, sin(t)/2)"
      ]
     },
     "execution_count": 303,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B-D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\frac{\\sqrt{3} \\sin{\\left(t \\right)}}{4}, \\  - \\frac{\\left(\\frac{1}{2} - \\frac{\\cos{\\left(t \\right)}}{2}\\right) \\sin{\\left(t \\right)}}{2} - \\frac{\\sin{\\left(t \\right)} \\cos{\\left(t \\right)}}{4}, \\  - \\frac{\\sqrt{3} \\cdot \\left(\\frac{1}{2} - \\frac{\\cos{\\left(t \\right)}}{2}\\right)}{2} - \\frac{\\sqrt{3} \\cos{\\left(t \\right)}}{2}\\right)$"
      ],
      "text/plain": [
       "(sqrt(3)*sin(t)/4, -(1/2 - cos(t)/2)*sin(t)/2 - sin(t)*cos(t)/4, -sqrt(3)*(1/2 - cos(t)/2)/2 - sqrt(3)*cos(t)/2)"
      ]
     },
     "execution_count": 307,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B,D,A).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\frac{\\sqrt{3} \\sin{\\left(t \\right)}}{4}, \\  - \\frac{\\sin{\\left(t \\right)}}{4}, \\  - \\frac{\\sqrt{3} \\left(\\cos{\\left(t \\right)} + 1\\right)}{4}\\right)$"
      ],
      "text/plain": [
       "(sqrt(3)*sin(t)/4, -sin(t)/4, -sqrt(3)*(cos(t) + 1)/4)"
      ]
     },
     "execution_count": 308,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trigsimp(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{10}}{8}$"
      ],
      "text/plain": [
       "sqrt(10)/8"
      ]
     },
     "execution_count": 309,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt((1/S(2)**2-(sqrt(6)/8)**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(0,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(2,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=Point(0,sqrt(12),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=Point(-2,sqrt(12),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=Point(1,0,sqrt(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=t*P+(1-t)*A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(t, 0, \\sqrt{3} t\\right)$"
      ],
      "text/plain": [
       "Point3D(t, 0, sqrt(3)*t)"
      ]
     },
     "execution_count": 316,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [],
   "source": [
    "F=t*P+(1-t)*C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(t, 2 \\sqrt{3} \\cdot \\left(1 - t\\right), \\sqrt{3} t\\right)$"
      ],
      "text/plain": [
       "Point3D(t, 2*sqrt(3)*(1 - t), sqrt(3)*t)"
      ]
     },
     "execution_count": 318,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 6, \\  2 \\sqrt{3}, \\  - 2 \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "(6, 2*sqrt(3), -2*sqrt(3))"
      ]
     },
     "execution_count": 321,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(P,A,D).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(\\frac{\\sqrt{15} \\left(- 36 t \\left(1 - t\\right) + 12 \\cdot \\left(1 - t\\right) \\left(2 - t\\right)\\right)}{30 \\sqrt{36 t^{2} \\left(1 - t\\right)^{2} + 12 \\left(1 - t\\right)^{2} \\left(2 - t\\right)^{2}}} \\right)}$"
      ],
      "text/plain": [
       "acos(sqrt(15)*(-36*t*(1 - t) + 12*(1 - t)*(2 - t))/(30*sqrt(36*t**2*(1 - t)**2 + 12*(1 - t)**2*(2 - t)**2)))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Plane(P,A,D).angle_between(Plane(E,F,B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{1}{2}\\right\\}$"
      ],
      "text/plain": [
       "{1/2}"
      ]
     },
     "execution_count": 320,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(simplify(cos(_)),t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, \\frac{2 \\sqrt{3}}{3}, \\frac{2 \\sqrt{3}}{3}\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 2*sqrt(3)/3, 2*sqrt(3)/3)"
      ]
     },
     "execution_count": 323,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line(P,D).intersection(Plane(B,E,F))[0].subs(t,1/S(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(0,-1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=-A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(sqrt(3),0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=-B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "metadata": {},
   "outputs": [],
   "source": [
    "F=Point(0,0,1)+A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, -1, 1\\right)$"
      ],
      "text/plain": [
       "Point3D(0, -1, 1)"
      ]
     },
     "execution_count": 329,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=(A+B)/2+Point(0,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{\\sqrt{3}}{2}, - \\frac{1}{2}, 1\\right)$"
      ],
      "text/plain": [
       "Point3D(sqrt(3)/2, -1/2, 1)"
      ]
     },
     "execution_count": 331,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=t*E+(1-t)*C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 0, \\  0, \\  2 \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "(0, 0, 2*sqrt(3))"
      ]
     },
     "execution_count": 333,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(A,B,D).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( t, \\  - \\sqrt{3} t, \\  - \\frac{\\sqrt{3} t}{2} + \\sqrt{3} \\cdot \\left(2 - \\frac{3 t}{2}\\right)\\right)$"
      ],
      "text/plain": [
       "(t, -sqrt(3)*t, -sqrt(3)*t/2 + sqrt(3)*(2 - 3*t/2))"
      ]
     },
     "execution_count": 336,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(A,B,P).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{- \\frac{\\sqrt{3} t}{2} + \\sqrt{3} \\cdot \\left(2 - \\frac{3 t}{2}\\right)}{t}$"
      ],
      "text/plain": [
       "(-sqrt(3)*t/2 + sqrt(3)*(2 - 3*t/2))/t"
      ]
     },
     "execution_count": 341,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(Plane(A,B,P).normal_vector[2]/t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2 \\sqrt{3} \\left(t - 1\\right)}{t}$"
      ],
      "text/plain": [
       "-2*sqrt(3)*(t - 1)/t"
      ]
     },
     "execution_count": 342,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(\\frac{- \\frac{\\sqrt{3} t}{2} + \\sqrt{3} \\cdot \\left(2 - \\frac{3 t}{2}\\right)}{\\sqrt{4 t^{2} + \\left(- \\frac{\\sqrt{3} t}{2} + \\sqrt{3} \\cdot \\left(2 - \\frac{3 t}{2}\\right)\\right)^{2}}} \\right)}$"
      ],
      "text/plain": [
       "acos((-sqrt(3)*t/2 + sqrt(3)*(2 - 3*t/2))/sqrt(4*t**2 + (-sqrt(3)*t/2 + sqrt(3)*(2 - 3*t/2))**2))"
      ]
     },
     "execution_count": 343,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(A,B,D).angle_between(Plane(A,B,P))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{2}{3}\\right\\}$"
      ],
      "text/plain": [
       "{2/3}"
      ]
     },
     "execution_count": 335,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(simplify(cos(_)-sqrt(21)/7),t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{2\\right\\}$"
      ],
      "text/plain": [
       "{2}"
      ]
     },
     "execution_count": 344,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(simplify(cos(_)+sqrt(21)/7),t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 345,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=Point(sqrt(3)/2,-3/S(2),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{\\sqrt{3}}{2}, - \\frac{3}{2}, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(sqrt(3)/2, -3/2, 0)"
      ]
     },
     "execution_count": 346,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(sqrt(3),0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 350,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(0,1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 351,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=-B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 352,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, -1, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(0, -1, 0)"
      ]
     },
     "execution_count": 352,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 353,
   "metadata": {},
   "outputs": [],
   "source": [
    "C1=Point(0,0,sqrt(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 354,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 0, \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 0, sqrt(3))"
      ]
     },
     "execution_count": 354,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 355,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=t*D+(1-t)*C1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 356,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{\\sqrt{3} t}{2}, - \\frac{3 t}{2}, \\sqrt{3} \\cdot \\left(1 - t\\right)\\right)$"
      ],
      "text/plain": [
       "Point3D(sqrt(3)*t/2, -3*t/2, sqrt(3)*(1 - t))"
      ]
     },
     "execution_count": 356,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left|{\\frac{3 \\sqrt{15} t}{10} - \\frac{\\sqrt{15} \\left(t - 2\\right)}{10} + \\frac{\\sqrt{15} \\left(t - 1\\right)}{5}}\\right|$"
      ],
      "text/plain": [
       "Abs(3*sqrt(15)*t/10 - sqrt(15)*(t - 2)/10 + sqrt(15)*(t - 1)/5)"
      ]
     },
     "execution_count": 357,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P.distance(Plane(A,B,C1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 358,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\sqrt{15} \\left|{t}\\right|}{5}$"
      ],
      "text/plain": [
       "2*sqrt(15)*Abs(t)/5"
      ]
     },
     "execution_count": 358,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{asin}{\\left(\\frac{\\sqrt{15}}{5} \\right)}$"
      ],
      "text/plain": [
       "asin(sqrt(15)/5)"
      ]
     },
     "execution_count": 359,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(A,B,C1).angle_between(Line(E,P.subs(t,1/S(2))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\sqrt{3}, \\  3, \\  \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "(sqrt(3), 3, sqrt(3))"
      ]
     },
     "execution_count": 360,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(A,B,C1).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 362,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{\\sqrt{3}}{4}, - \\frac{3}{4}, \\frac{\\sqrt{3}}{2}\\right)$"
      ],
      "text/plain": [
       "Point3D(sqrt(3)/4, -3/4, sqrt(3)/2)"
      ]
     },
     "execution_count": 362,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P.subs(t,1/S(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(- \\frac{3 \\sqrt{3}}{4}, - \\frac{3}{4}, \\frac{\\sqrt{3}}{2}\\right)$"
      ],
      "text/plain": [
       "Point3D(-3*sqrt(3)/4, -3/4, sqrt(3)/2)"
      ]
     },
     "execution_count": 364,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P.subs(t,1/S(2))-A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 365,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{\\sqrt{3}}{4}, \\frac{1}{4}, \\frac{\\sqrt{3}}{2}\\right)$"
      ],
      "text/plain": [
       "Point3D(sqrt(3)/4, 1/4, sqrt(3)/2)"
      ]
     },
     "execution_count": 365,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P.subs(t,1/S(2))-E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "metadata": {},
   "outputs": [],
   "source": [
    "F=Point(0,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=Point(0,sqrt(3),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(0,1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=-3*A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, -3, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(0, -3, 0)"
      ]
     },
     "execution_count": 370,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=Point(sqrt(12),3,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "metadata": {},
   "outputs": [],
   "source": [
    "B1=Point(0,3*cos(pi/3),3*sin(pi/3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, \\frac{3}{2}, \\frac{3 \\sqrt{3}}{2}\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 3/2, 3*sqrt(3)/2)"
      ]
     },
     "execution_count": 375,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "B1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "metadata": {},
   "outputs": [],
   "source": [
    "M=t*A+(1-t)*C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(2 \\sqrt{3} \\cdot \\left(1 - t\\right), 3 - 2 t, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(2*sqrt(3)*(1 - t), 3 - 2*t, 0)"
      ]
     },
     "execution_count": 377,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( - \\frac{87 \\sqrt{3}}{56}, \\  \\frac{9}{56}, \\  - \\frac{3 \\sqrt{3}}{56}\\right)$"
      ],
      "text/plain": [
       "(-87*sqrt(3)/56, 9/56, -3*sqrt(3)/56)"
      ]
     },
     "execution_count": 390,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B1,M,F).normal_vector.subs(t,55/S(56))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 381,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{asin}{\\left(\\frac{\\sqrt{3} \\left(- 54 t + 2 \\sqrt{3} \\left(- \\frac{3 \\sqrt{3} \\cdot \\left(\\frac{3}{2} - 2 t\\right)}{2} - \\frac{9 \\sqrt{3}}{4}\\right) + 54\\right)}{12 \\sqrt{27 \\left(1 - t\\right)^{2} + \\left(9 - 9 t\\right)^{2} + \\left(- \\frac{3 \\sqrt{3} \\cdot \\left(\\frac{3}{2} - 2 t\\right)}{2} - \\frac{9 \\sqrt{3}}{4}\\right)^{2}}} \\right)}$"
      ],
      "text/plain": [
       "asin(sqrt(3)*(-54*t + 2*sqrt(3)*(-3*sqrt(3)*(3/2 - 2*t)/2 - 9*sqrt(3)/4) + 54)/(12*sqrt(27*(1 - t)**2 + (9 - 9*t)**2 + (-3*sqrt(3)*(3/2 - 2*t)/2 - 9*sqrt(3)/4)**2)))"
      ]
     },
     "execution_count": 381,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B1,M,F).angle_between(Line(B,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 382,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{55}{56}\\right\\}$"
      ],
      "text/plain": [
       "{55/56}"
      ]
     },
     "execution_count": 382,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(simplify(sin(_)+1/sqrt(5)),t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\operatorname{asin}{\\left(\\frac{\\sqrt{5}}{5} \\right)}$"
      ],
      "text/plain": [
       "-asin(sqrt(5)/5)"
      ]
     },
     "execution_count": 383,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(B1,M.subs(t,55/S(56)),F).angle_between(Line(B,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 391,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=Point(0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 392,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=Point(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(-sqrt(3),2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(-sqrt(3),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=Point(0,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 396,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyd=Pyramid(P,Polygon(D,C,B,A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( \\operatorname{Point3D}\\left(0, 0, 1\\right), \\  \\operatorname{Point3D}\\left(0, 0, 0\\right), \\  \\operatorname{Point3D}\\left(0, 1, 0\\right), \\  \\operatorname{Point3D}\\left(- \\sqrt{3}, 2, 0\\right), \\  \\operatorname{Point3D}\\left(- \\sqrt{3}, 0, 0\\right)\\right)$"
      ],
      "text/plain": [
       "(Point3D(0, 0, 1), Point3D(0, 0, 0), Point3D(0, 1, 0), Point3D(-sqrt(3), 2, 0), Point3D(-sqrt(3), 0, 0))"
      ]
     },
     "execution_count": 397,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pyd.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 403,
   "metadata": {},
   "outputs": [],
   "source": [
    "P,D,C,B,A=pyd.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 1, \\  - \\sqrt{3}, \\  - \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "(1, -sqrt(3), -sqrt(3))"
      ]
     },
     "execution_count": 411,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(A,C,P).normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{acos}{\\left(\\frac{\\sqrt{21}}{7} \\right)}$"
      ],
      "text/plain": [
       "acos(sqrt(21)/7)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Plane(A,C,P).angle_between(Plane(A,B,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=t*P+(1-t)*B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\sqrt{3} \\left(t - 1\\right), 2 - 2 t, t\\right)$"
      ],
      "text/plain": [
       "Point3D(sqrt(3)*(t - 1), 2 - 2*t, t)"
      ]
     },
     "execution_count": 406,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 409,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{asin}{\\left(\\frac{\\sqrt{7} \\left(- \\sqrt{3} t - \\sqrt{3} \\cdot \\left(2 - 2 t\\right) + \\sqrt{3} \\left(t - 1\\right)\\right)}{7 \\sqrt{t^{2} + \\left(2 - 2 t\\right)^{2} + 3 \\left(t - 1\\right)^{2}}} \\right)}$"
      ],
      "text/plain": [
       "asin(sqrt(7)*(-sqrt(3)*t - sqrt(3)*(2 - 2*t) + sqrt(3)*(t - 1))/(7*sqrt(t**2 + (2 - 2*t)**2 + 3*(t - 1)**2)))"
      ]
     },
     "execution_count": 409,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Plane(A,C,P).angle_between(Line(D,E))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 408,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{1}{2}, 1\\right\\}$"
      ],
      "text/plain": [
       "{-1/2, 1}"
      ]
     },
     "execution_count": 408,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(sin(_)+sqrt(21)/7,t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 410,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\emptyset$"
      ],
      "text/plain": [
       "EmptySet"
      ]
     },
     "execution_count": 410,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(sin(_)-sqrt(21)/7,t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
